git.squeep.com Git - akkoma/blob - test/user_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.UserTest do
   6   alias Pleroma.Activity
   7   alias Pleroma.Builders.UserBuilder
   8   alias Pleroma.Object
   9   alias Pleroma.Repo
  10   alias Pleroma.Tests.ObanHelpers
  11   alias Pleroma.User
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.CommonAPI
  14
  15   use Pleroma.DataCase
  16   use Oban.Testing, repo: Pleroma.Repo
  17
  18   import Mock
  19   import Pleroma.Factory
  20
  21   setup_all do
  22     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  23     :ok
  24   end
  25
  26   clear_config([:instance, :account_activation_required])
  27
  28   describe "when tags are nil" do
  29     test "tagging a user" do
  30       user = insert(:user, %{tags: nil})
  31       user = User.tag(user, ["cool", "dude"])
  32
  33       assert "cool" in user.tags
  34       assert "dude" in user.tags
  35     end
  36
  37     test "untagging a user" do
  38       user = insert(:user, %{tags: nil})
  39       user = User.untag(user, ["cool", "dude"])
  40
  41       assert user.tags == []
  42     end
  43   end
  44
  45   test "ap_id returns the activity pub id for the user" do
  46     user = UserBuilder.build()
  47
  48     expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
  49
  50     assert expected_ap_id == User.ap_id(user)
  51   end
  52
  53   test "ap_followers returns the followers collection for the user" do
  54     user = UserBuilder.build()
  55
  56     expected_followers_collection = "#{User.ap_id(user)}/followers"
  57
  58     assert expected_followers_collection == User.ap_followers(user)
  59   end
  60
  61   test "ap_following returns the following collection for the user" do
  62     user = UserBuilder.build()
  63
  64     expected_followers_collection = "#{User.ap_id(user)}/following"
  65
  66     assert expected_followers_collection == User.ap_following(user)
  67   end
  68
  69   test "returns all pending follow requests" do
  70     unlocked = insert(:user)
  71     locked = insert(:user, %{info: %{locked: true}})
  72     follower = insert(:user)
  73
  74     CommonAPI.follow(follower, unlocked)
  75     CommonAPI.follow(follower, locked)
  76
  77     assert [] = User.get_follow_requests(unlocked)
  78     assert [activity] = User.get_follow_requests(locked)
  79
  80     assert activity
  81   end
  82
  83   test "doesn't return already accepted or duplicate follow requests" do
  84     locked = insert(:user, %{info: %{locked: true}})
  85     pending_follower = insert(:user)
  86     accepted_follower = insert(:user)
  87
  88     CommonAPI.follow(pending_follower, locked)
  89     CommonAPI.follow(pending_follower, locked)
  90     CommonAPI.follow(accepted_follower, locked)
  91     Pleroma.FollowingRelationship.update(accepted_follower, locked, "accept")
  92
  93     assert [^pending_follower] = User.get_follow_requests(locked)
  94   end
  95
  96   test "clears follow requests when requester is blocked" do
  97     followed = insert(:user, %{info: %{locked: true}})
  98     follower = insert(:user)
  99
 100     CommonAPI.follow(follower, followed)
 101     assert [_activity] = User.get_follow_requests(followed)
 102
 103     {:ok, _follower} = User.block(followed, follower)
 104     assert [] = User.get_follow_requests(followed)
 105   end
 106
 107   test "follow_all follows mutliple users" do
 108     user = insert(:user)
 109     followed_zero = insert(:user)
 110     followed_one = insert(:user)
 111     followed_two = insert(:user)
 112     blocked = insert(:user)
 113     not_followed = insert(:user)
 114     reverse_blocked = insert(:user)
 115
 116     {:ok, user} = User.block(user, blocked)
 117     {:ok, reverse_blocked} = User.block(reverse_blocked, user)
 118
 119     {:ok, user} = User.follow(user, followed_zero)
 120
 121     {:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])
 122
 123     assert User.following?(user, followed_one)
 124     assert User.following?(user, followed_two)
 125     assert User.following?(user, followed_zero)
 126     refute User.following?(user, not_followed)
 127     refute User.following?(user, blocked)
 128     refute User.following?(user, reverse_blocked)
 129   end
 130
 131   test "follow_all follows mutliple users without duplicating" do
 132     user = insert(:user)
 133     followed_zero = insert(:user)
 134     followed_one = insert(:user)
 135     followed_two = insert(:user)
 136
 137     {:ok, user} = User.follow_all(user, [followed_zero, followed_one])
 138     assert length(User.following(user)) == 3
 139
 140     {:ok, user} = User.follow_all(user, [followed_one, followed_two])
 141     assert length(User.following(user)) == 4
 142   end
 143
 144   test "follow takes a user and another user" do
 145     user = insert(:user)
 146     followed = insert(:user)
 147
 148     {:ok, user} = User.follow(user, followed)
 149
 150     user = User.get_cached_by_id(user.id)
 151
 152     followed = User.get_cached_by_ap_id(followed.ap_id)
 153     assert followed.info.follower_count == 1
 154
 155     assert User.ap_followers(followed) in User.following(user)
 156   end
 157
 158   test "can't follow a deactivated users" do
 159     user = insert(:user)
 160     followed = insert(:user, info: %{deactivated: true})
 161
 162     {:error, _} = User.follow(user, followed)
 163   end
 164
 165   test "can't follow a user who blocked us" do
 166     blocker = insert(:user)
 167     blockee = insert(:user)
 168
 169     {:ok, blocker} = User.block(blocker, blockee)
 170
 171     {:error, _} = User.follow(blockee, blocker)
 172   end
 173
 174   test "can't subscribe to a user who blocked us" do
 175     blocker = insert(:user)
 176     blocked = insert(:user)
 177
 178     {:ok, blocker} = User.block(blocker, blocked)
 179
 180     {:error, _} = User.subscribe(blocked, blocker)
 181   end
 182
 183   test "local users do not automatically follow local locked accounts" do
 184     follower = insert(:user, info: %{locked: true})
 185     followed = insert(:user, info: %{locked: true})
 186
 187     {:ok, follower} = User.maybe_direct_follow(follower, followed)
 188
 189     refute User.following?(follower, followed)
 190   end
 191
 192   # This is a somewhat useless test.
 193   # test "following a remote user will ensure a websub subscription is present" do
 194   #   user = insert(:user)
 195   #   {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")
 196
 197   #   assert followed.local == false
 198
 199   #   {:ok, user} = User.follow(user, followed)
 200   #   assert User.ap_followers(followed) in User.following(user)
 201
 202   #   query = from w in WebsubClientSubscription,
 203   #   where: w.topic == ^followed.info["topic"]
 204   #   websub = Repo.one(query)
 205
 206   #   assert websub
 207   # end
 208
 209   describe "unfollow/2" do
 210     setup do
 211       setting = Pleroma.Config.get([:instance, :external_user_synchronization])
 212
 213       on_exit(fn ->
 214         Pleroma.Config.put([:instance, :external_user_synchronization], setting)
 215       end)
 216
 217       :ok
 218     end
 219
 220     test "unfollow with syncronizes external user" do
 221       Pleroma.Config.put([:instance, :external_user_synchronization], true)
 222
 223       followed =
 224         insert(:user,
 225           nickname: "fuser1",
 226           follower_address: "http://localhost:4001/users/fuser1/followers",
 227           following_address: "http://localhost:4001/users/fuser1/following",
 228           ap_id: "http://localhost:4001/users/fuser1"
 229         )
 230
 231       user =
 232         insert(:user, %{
 233           local: false,
 234           nickname: "fuser2",
 235           ap_id: "http://localhost:4001/users/fuser2",
 236           follower_address: "http://localhost:4001/users/fuser2/followers",
 237           following_address: "http://localhost:4001/users/fuser2/following"
 238         })
 239
 240       {:ok, user} = User.follow(user, followed, "accept")
 241
 242       {:ok, user, _activity} = User.unfollow(user, followed)
 243
 244       user = User.get_cached_by_id(user.id)
 245
 246       assert User.following(user) == []
 247     end
 248
 249     test "unfollow takes a user and another user" do
 250       followed = insert(:user)
 251       user = insert(:user)
 252
 253       {:ok, user} = User.follow(user, followed, "accept")
 254
 255       assert User.following(user) == [user.follower_address, followed.follower_address]
 256
 257       {:ok, user, _activity} = User.unfollow(user, followed)
 258
 259       assert User.following(user) == [user.follower_address]
 260     end
 261
 262     test "unfollow doesn't unfollow yourself" do
 263       user = insert(:user)
 264
 265       {:error, _} = User.unfollow(user, user)
 266
 267       assert User.following(user) == [user.follower_address]
 268     end
 269   end
 270
 271   test "test if a user is following another user" do
 272     followed = insert(:user)
 273     user = insert(:user)
 274     User.follow(user, followed, "accept")
 275
 276     assert User.following?(user, followed)
 277     refute User.following?(followed, user)
 278   end
 279
 280   test "fetches correct profile for nickname beginning with number" do
 281     # Use old-style integer ID to try to reproduce the problem
 282     user = insert(:user, %{id: 1080})
 283     user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
 284     assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
 285   end
 286
 287   describe "user registration" do
 288     @full_user_data %{
 289       bio: "A guy",
 290       name: "my name",
 291       nickname: "nick",
 292       password: "test",
 293       password_confirmation: "test",
 294       email: "email@example.com"
 295     }
 296     clear_config([:instance, :autofollowed_nicknames])
 297     clear_config([:instance, :welcome_message])
 298     clear_config([:instance, :welcome_user_nickname])
 299
 300     test "it autofollows accounts that are set for it" do
 301       user = insert(:user)
 302       remote_user = insert(:user, %{local: false})
 303
 304       Pleroma.Config.put([:instance, :autofollowed_nicknames], [
 305         user.nickname,
 306         remote_user.nickname
 307       ])
 308
 309       cng = User.register_changeset(%User{}, @full_user_data)
 310
 311       {:ok, registered_user} = User.register(cng)
 312
 313       assert User.following?(registered_user, user)
 314       refute User.following?(registered_user, remote_user)
 315     end
 316
 317     test "it sends a welcome message if it is set" do
 318       welcome_user = insert(:user)
 319
 320       Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
 321       Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")
 322
 323       cng = User.register_changeset(%User{}, @full_user_data)
 324       {:ok, registered_user} = User.register(cng)
 325
 326       activity = Repo.one(Pleroma.Activity)
 327       assert registered_user.ap_id in activity.recipients
 328       assert Object.normalize(activity).data["content"] =~ "cool site"
 329       assert activity.actor == welcome_user.ap_id
 330     end
 331
 332     test "it requires an email, name, nickname and password, bio is optional" do
 333       @full_user_data
 334       |> Map.keys()
 335       |> Enum.each(fn key ->
 336         params = Map.delete(@full_user_data, key)
 337         changeset = User.register_changeset(%User{}, params)
 338
 339         assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
 340       end)
 341     end
 342
 343     test "it restricts certain nicknames" do
 344       [restricted_name | _] = Pleroma.Config.get([User, :restricted_nicknames])
 345
 346       assert is_bitstring(restricted_name)
 347
 348       params =
 349         @full_user_data
 350         |> Map.put(:nickname, restricted_name)
 351
 352       changeset = User.register_changeset(%User{}, params)
 353
 354       refute changeset.valid?
 355     end
 356
 357     test "it sets the password_hash and ap_id" do
 358       changeset = User.register_changeset(%User{}, @full_user_data)
 359
 360       assert changeset.valid?
 361
 362       assert is_binary(changeset.changes[:password_hash])
 363       assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
 364
 365       assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
 366     end
 367
 368     test "it ensures info is not nil" do
 369       changeset = User.register_changeset(%User{}, @full_user_data)
 370
 371       assert changeset.valid?
 372
 373       {:ok, user} =
 374         changeset
 375         |> Repo.insert()
 376
 377       refute is_nil(user.info)
 378     end
 379   end
 380
 381   describe "user registration, with :account_activation_required" do
 382     @full_user_data %{
 383       bio: "A guy",
 384       name: "my name",
 385       nickname: "nick",
 386       password: "test",
 387       password_confirmation: "test",
 388       email: "email@example.com"
 389     }
 390
 391     clear_config([:instance, :account_activation_required]) do
 392       Pleroma.Config.put([:instance, :account_activation_required], true)
 393     end
 394
 395     test "it creates unconfirmed user" do
 396       changeset = User.register_changeset(%User{}, @full_user_data)
 397       assert changeset.valid?
 398
 399       {:ok, user} = Repo.insert(changeset)
 400
 401       assert user.info.confirmation_pending
 402       assert user.info.confirmation_token
 403     end
 404
 405     test "it creates confirmed user if :confirmed option is given" do
 406       changeset = User.register_changeset(%User{}, @full_user_data, need_confirmation: false)
 407       assert changeset.valid?
 408
 409       {:ok, user} = Repo.insert(changeset)
 410
 411       refute user.info.confirmation_pending
 412       refute user.info.confirmation_token
 413     end
 414   end
 415
 416   describe "get_or_fetch/1" do
 417     test "gets an existing user by nickname" do
 418       user = insert(:user)
 419       {:ok, fetched_user} = User.get_or_fetch(user.nickname)
 420
 421       assert user == fetched_user
 422     end
 423
 424     test "gets an existing user by ap_id" do
 425       ap_id = "http://mastodon.example.org/users/admin"
 426
 427       user =
 428         insert(
 429           :user,
 430           local: false,
 431           nickname: "admin@mastodon.example.org",
 432           ap_id: ap_id,
 433           info: %{}
 434         )
 435
 436       {:ok, fetched_user} = User.get_or_fetch(ap_id)
 437       freshed_user = refresh_record(user)
 438       assert freshed_user == fetched_user
 439     end
 440   end
 441
 442   describe "fetching a user from nickname or trying to build one" do
 443     test "gets an existing user" do
 444       user = insert(:user)
 445       {:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)
 446
 447       assert user == fetched_user
 448     end
 449
 450     test "gets an existing user, case insensitive" do
 451       user = insert(:user, nickname: "nick")
 452       {:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")
 453
 454       assert user == fetched_user
 455     end
 456
 457     test "gets an existing user by fully qualified nickname" do
 458       user = insert(:user)
 459
 460       {:ok, fetched_user} =
 461         User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
 462
 463       assert user == fetched_user
 464     end
 465
 466     test "gets an existing user by fully qualified nickname, case insensitive" do
 467       user = insert(:user, nickname: "nick")
 468       casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
 469
 470       {:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)
 471
 472       assert user == fetched_user
 473     end
 474
 475     test "fetches an external user via ostatus if no user exists" do
 476       {:ok, fetched_user} = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
 477       assert fetched_user.nickname == "shp@social.heldscal.la"
 478     end
 479
 480     test "returns nil if no user could be fetched" do
 481       {:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
 482       assert fetched_user == "not found nonexistant@social.heldscal.la"
 483     end
 484
 485     test "returns nil for nonexistant local user" do
 486       {:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
 487       assert fetched_user == "not found nonexistant"
 488     end
 489
 490     test "updates an existing user, if stale" do
 491       a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
 492
 493       orig_user =
 494         insert(
 495           :user,
 496           local: false,
 497           nickname: "admin@mastodon.example.org",
 498           ap_id: "http://mastodon.example.org/users/admin",
 499           last_refreshed_at: a_week_ago,
 500           info: %{}
 501         )
 502
 503       assert orig_user.last_refreshed_at == a_week_ago
 504
 505       {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
 506       assert user.info.source_data["endpoints"]
 507
 508       refute user.last_refreshed_at == orig_user.last_refreshed_at
 509     end
 510   end
 511
 512   test "returns an ap_id for a user" do
 513     user = insert(:user)
 514
 515     assert User.ap_id(user) ==
 516              Pleroma.Web.Router.Helpers.feed_url(
 517                Pleroma.Web.Endpoint,
 518                :feed_redirect,
 519                user.nickname
 520              )
 521   end
 522
 523   test "returns an ap_followers link for a user" do
 524     user = insert(:user)
 525
 526     assert User.ap_followers(user) ==
 527              Pleroma.Web.Router.Helpers.feed_url(
 528                Pleroma.Web.Endpoint,
 529                :feed_redirect,
 530                user.nickname
 531              ) <> "/followers"
 532   end
 533
 534   describe "remote user creation changeset" do
 535     @valid_remote %{
 536       bio: "hello",
 537       name: "Someone",
 538       nickname: "a@b.de",
 539       ap_id: "http...",
 540       info: %{some: "info"},
 541       avatar: %{some: "avatar"}
 542     }
 543
 544     clear_config([:instance, :user_bio_length])
 545     clear_config([:instance, :user_name_length])
 546
 547     test "it confirms validity" do
 548       cs = User.remote_user_creation(@valid_remote)
 549       assert cs.valid?
 550     end
 551
 552     test "it sets the follower_adress" do
 553       cs = User.remote_user_creation(@valid_remote)
 554       # remote users get a fake local follower address
 555       assert cs.changes.follower_address ==
 556                User.ap_followers(%User{nickname: @valid_remote[:nickname]})
 557     end
 558
 559     test "it enforces the fqn format for nicknames" do
 560       cs = User.remote_user_creation(%{@valid_remote | nickname: "bla"})
 561       assert Ecto.Changeset.get_field(cs, :local) == false
 562       assert cs.changes.avatar
 563       refute cs.valid?
 564     end
 565
 566     test "it has required fields" do
 567       [:name, :ap_id]
 568       |> Enum.each(fn field ->
 569         cs = User.remote_user_creation(Map.delete(@valid_remote, field))
 570         refute cs.valid?
 571       end)
 572     end
 573   end
 574
 575   describe "followers and friends" do
 576     test "gets all followers for a given user" do
 577       user = insert(:user)
 578       follower_one = insert(:user)
 579       follower_two = insert(:user)
 580       not_follower = insert(:user)
 581
 582       {:ok, follower_one} = User.follow(follower_one, user)
 583       {:ok, follower_two} = User.follow(follower_two, user)
 584
 585       res = User.get_followers(user)
 586
 587       assert Enum.member?(res, follower_one)
 588       assert Enum.member?(res, follower_two)
 589       refute Enum.member?(res, not_follower)
 590     end
 591
 592     test "gets all friends (followed users) for a given user" do
 593       user = insert(:user)
 594       followed_one = insert(:user)
 595       followed_two = insert(:user)
 596       not_followed = insert(:user)
 597
 598       {:ok, user} = User.follow(user, followed_one)
 599       {:ok, user} = User.follow(user, followed_two)
 600
 601       res = User.get_friends(user)
 602
 603       followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
 604       followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
 605       assert Enum.member?(res, followed_one)
 606       assert Enum.member?(res, followed_two)
 607       refute Enum.member?(res, not_followed)
 608     end
 609   end
 610
 611   describe "updating note and follower count" do
 612     test "it sets the info->note_count property" do
 613       note = insert(:note)
 614
 615       user = User.get_cached_by_ap_id(note.data["actor"])
 616
 617       assert user.info.note_count == 0
 618
 619       {:ok, user} = User.update_note_count(user)
 620
 621       assert user.info.note_count == 1
 622     end
 623
 624     test "it increases the info->note_count property" do
 625       note = insert(:note)
 626       user = User.get_cached_by_ap_id(note.data["actor"])
 627
 628       assert user.info.note_count == 0
 629
 630       {:ok, user} = User.increase_note_count(user)
 631
 632       assert user.info.note_count == 1
 633
 634       {:ok, user} = User.increase_note_count(user)
 635
 636       assert user.info.note_count == 2
 637     end
 638
 639     test "it decreases the info->note_count property" do
 640       note = insert(:note)
 641       user = User.get_cached_by_ap_id(note.data["actor"])
 642
 643       assert user.info.note_count == 0
 644
 645       {:ok, user} = User.increase_note_count(user)
 646
 647       assert user.info.note_count == 1
 648
 649       {:ok, user} = User.decrease_note_count(user)
 650
 651       assert user.info.note_count == 0
 652
 653       {:ok, user} = User.decrease_note_count(user)
 654
 655       assert user.info.note_count == 0
 656     end
 657
 658     test "it sets the info->follower_count property" do
 659       user = insert(:user)
 660       follower = insert(:user)
 661
 662       User.follow(follower, user)
 663
 664       assert user.info.follower_count == 0
 665
 666       {:ok, user} = User.update_follower_count(user)
 667
 668       assert user.info.follower_count == 1
 669     end
 670   end
 671
 672   describe "follow_import" do
 673     test "it imports user followings from list" do
 674       [user1, user2, user3] = insert_list(3, :user)
 675
 676       identifiers = [
 677         user2.ap_id,
 678         user3.nickname
 679       ]
 680
 681       {:ok, job} = User.follow_import(user1, identifiers)
 682       result = ObanHelpers.perform(job)
 683
 684       assert is_list(result)
 685       assert result == [user2, user3]
 686     end
 687   end
 688
 689   describe "mutes" do
 690     test "it mutes people" do
 691       user = insert(:user)
 692       muted_user = insert(:user)
 693
 694       refute User.mutes?(user, muted_user)
 695       refute User.muted_notifications?(user, muted_user)
 696
 697       {:ok, user} = User.mute(user, muted_user)
 698
 699       assert User.mutes?(user, muted_user)
 700       assert User.muted_notifications?(user, muted_user)
 701     end
 702
 703     test "it unmutes users" do
 704       user = insert(:user)
 705       muted_user = insert(:user)
 706
 707       {:ok, user} = User.mute(user, muted_user)
 708       {:ok, user} = User.unmute(user, muted_user)
 709
 710       refute User.mutes?(user, muted_user)
 711       refute User.muted_notifications?(user, muted_user)
 712     end
 713
 714     test "it mutes user without notifications" do
 715       user = insert(:user)
 716       muted_user = insert(:user)
 717
 718       refute User.mutes?(user, muted_user)
 719       refute User.muted_notifications?(user, muted_user)
 720
 721       {:ok, user} = User.mute(user, muted_user, false)
 722
 723       assert User.mutes?(user, muted_user)
 724       refute User.muted_notifications?(user, muted_user)
 725     end
 726   end
 727
 728   describe "blocks" do
 729     test "it blocks people" do
 730       user = insert(:user)
 731       blocked_user = insert(:user)
 732
 733       refute User.blocks?(user, blocked_user)
 734
 735       {:ok, user} = User.block(user, blocked_user)
 736
 737       assert User.blocks?(user, blocked_user)
 738     end
 739
 740     test "it unblocks users" do
 741       user = insert(:user)
 742       blocked_user = insert(:user)
 743
 744       {:ok, user} = User.block(user, blocked_user)
 745       {:ok, user} = User.unblock(user, blocked_user)
 746
 747       refute User.blocks?(user, blocked_user)
 748     end
 749
 750     test "blocks tear down cyclical follow relationships" do
 751       blocker = insert(:user)
 752       blocked = insert(:user)
 753
 754       {:ok, blocker} = User.follow(blocker, blocked)
 755       {:ok, blocked} = User.follow(blocked, blocker)
 756
 757       assert User.following?(blocker, blocked)
 758       assert User.following?(blocked, blocker)
 759
 760       {:ok, blocker} = User.block(blocker, blocked)
 761       blocked = User.get_cached_by_id(blocked.id)
 762
 763       assert User.blocks?(blocker, blocked)
 764
 765       refute User.following?(blocker, blocked)
 766       refute User.following?(blocked, blocker)
 767     end
 768
 769     test "blocks tear down blocker->blocked follow relationships" do
 770       blocker = insert(:user)
 771       blocked = insert(:user)
 772
 773       {:ok, blocker} = User.follow(blocker, blocked)
 774
 775       assert User.following?(blocker, blocked)
 776       refute User.following?(blocked, blocker)
 777
 778       {:ok, blocker} = User.block(blocker, blocked)
 779       blocked = User.get_cached_by_id(blocked.id)
 780
 781       assert User.blocks?(blocker, blocked)
 782
 783       refute User.following?(blocker, blocked)
 784       refute User.following?(blocked, blocker)
 785     end
 786
 787     test "blocks tear down blocked->blocker follow relationships" do
 788       blocker = insert(:user)
 789       blocked = insert(:user)
 790
 791       {:ok, blocked} = User.follow(blocked, blocker)
 792
 793       refute User.following?(blocker, blocked)
 794       assert User.following?(blocked, blocker)
 795
 796       {:ok, blocker} = User.block(blocker, blocked)
 797       blocked = User.get_cached_by_id(blocked.id)
 798
 799       assert User.blocks?(blocker, blocked)
 800
 801       refute User.following?(blocker, blocked)
 802       refute User.following?(blocked, blocker)
 803     end
 804
 805     test "blocks tear down blocked->blocker subscription relationships" do
 806       blocker = insert(:user)
 807       blocked = insert(:user)
 808
 809       {:ok, blocker} = User.subscribe(blocked, blocker)
 810
 811       assert User.subscribed_to?(blocked, blocker)
 812       refute User.subscribed_to?(blocker, blocked)
 813
 814       {:ok, blocker} = User.block(blocker, blocked)
 815
 816       assert User.blocks?(blocker, blocked)
 817       refute User.subscribed_to?(blocker, blocked)
 818       refute User.subscribed_to?(blocked, blocker)
 819     end
 820   end
 821
 822   describe "domain blocking" do
 823     test "blocks domains" do
 824       user = insert(:user)
 825       collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
 826
 827       {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
 828
 829       assert User.blocks?(user, collateral_user)
 830     end
 831
 832     test "does not block domain with same end" do
 833       user = insert(:user)
 834
 835       collateral_user =
 836         insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
 837
 838       {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
 839
 840       refute User.blocks?(user, collateral_user)
 841     end
 842
 843     test "does not block domain with same end if wildcard added" do
 844       user = insert(:user)
 845
 846       collateral_user =
 847         insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
 848
 849       {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
 850
 851       refute User.blocks?(user, collateral_user)
 852     end
 853
 854     test "blocks domain with wildcard for subdomain" do
 855       user = insert(:user)
 856
 857       user_from_subdomain =
 858         insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})
 859
 860       user_with_two_subdomains =
 861         insert(:user, %{
 862           ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
 863         })
 864
 865       user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
 866
 867       {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
 868
 869       assert User.blocks?(user, user_from_subdomain)
 870       assert User.blocks?(user, user_with_two_subdomains)
 871       assert User.blocks?(user, user_domain)
 872     end
 873
 874     test "unblocks domains" do
 875       user = insert(:user)
 876       collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
 877
 878       {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
 879       {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")
 880
 881       refute User.blocks?(user, collateral_user)
 882     end
 883   end
 884
 885   describe "blocks_import" do
 886     test "it imports user blocks from list" do
 887       [user1, user2, user3] = insert_list(3, :user)
 888
 889       identifiers = [
 890         user2.ap_id,
 891         user3.nickname
 892       ]
 893
 894       {:ok, job} = User.blocks_import(user1, identifiers)
 895       result = ObanHelpers.perform(job)
 896
 897       assert is_list(result)
 898       assert result == [user2, user3]
 899     end
 900   end
 901
 902   test "get recipients from activity" do
 903     actor = insert(:user)
 904     user = insert(:user, local: true)
 905     user_two = insert(:user, local: false)
 906     addressed = insert(:user, local: true)
 907     addressed_remote = insert(:user, local: false)
 908
 909     {:ok, activity} =
 910       CommonAPI.post(actor, %{
 911         "status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
 912       })
 913
 914     assert Enum.map([actor, addressed], & &1.ap_id) --
 915              Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
 916
 917     {:ok, user} = User.follow(user, actor)
 918     {:ok, _user_two} = User.follow(user_two, actor)
 919     recipients = User.get_recipients_from_activity(activity)
 920     assert length(recipients) == 3
 921     assert user in recipients
 922     assert addressed in recipients
 923   end
 924
 925   describe ".deactivate" do
 926     test "can de-activate then re-activate a user" do
 927       user = insert(:user)
 928       assert false == user.info.deactivated
 929       {:ok, user} = User.deactivate(user)
 930       assert true == user.info.deactivated
 931       {:ok, user} = User.deactivate(user, false)
 932       assert false == user.info.deactivated
 933     end
 934
 935     test "hide a user from followers " do
 936       user = insert(:user)
 937       user2 = insert(:user)
 938
 939       {:ok, user} = User.follow(user, user2)
 940       {:ok, _user} = User.deactivate(user)
 941
 942       info = User.get_cached_user_info(user2)
 943
 944       assert info.follower_count == 0
 945       assert [] = User.get_followers(user2)
 946     end
 947
 948     test "hide a user from friends" do
 949       user = insert(:user)
 950       user2 = insert(:user)
 951
 952       {:ok, user2} = User.follow(user2, user)
 953       assert User.following_count(user2) == 1
 954
 955       {:ok, _user} = User.deactivate(user)
 956
 957       info = User.get_cached_user_info(user2)
 958
 959       assert info.following_count == 0
 960       assert User.following_count(user2) == 0
 961       assert [] = User.get_friends(user2)
 962     end
 963
 964     test "hide a user's statuses from timelines and notifications" do
 965       user = insert(:user)
 966       user2 = insert(:user)
 967
 968       {:ok, user2} = User.follow(user2, user)
 969
 970       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}"})
 971
 972       activity = Repo.preload(activity, :bookmark)
 973
 974       [notification] = Pleroma.Notification.for_user(user2)
 975       assert notification.activity.id == activity.id
 976
 977       assert [activity] == ActivityPub.fetch_public_activities(%{}) |> Repo.preload(:bookmark)
 978
 979       assert [%{activity | thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
 980                ActivityPub.fetch_activities([user2.ap_id | User.following(user2)], %{
 981                  "user" => user2
 982                })
 983
 984       {:ok, _user} = User.deactivate(user)
 985
 986       assert [] == ActivityPub.fetch_public_activities(%{})
 987       assert [] == Pleroma.Notification.for_user(user2)
 988
 989       assert [] ==
 990                ActivityPub.fetch_activities([user2.ap_id | User.following(user2)], %{
 991                  "user" => user2
 992                })
 993     end
 994   end
 995
 996   describe "delete" do
 997     setup do
 998       {:ok, user} = insert(:user) |> User.set_cache()
 999
1000       [user: user]
1001     end
1002
1003     clear_config([:instance, :federating])
1004
1005     test ".delete_user_activities deletes all create activities", %{user: user} do
1006       {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
1007
1008       User.delete_user_activities(user)
1009
1010       # TODO: Remove favorites, repeats, delete activities.
1011       refute Activity.get_by_id(activity.id)
1012     end
1013
1014     test "it deletes deactivated user" do
1015       {:ok, user} = insert(:user, info: %{deactivated: true}) |> User.set_cache()
1016
1017       {:ok, job} = User.delete(user)
1018       {:ok, _user} = ObanHelpers.perform(job)
1019
1020       refute User.get_by_id(user.id)
1021     end
1022
1023     test "it deletes a user, all follow relationships and all activities", %{user: user} do
1024       follower = insert(:user)
1025       {:ok, follower} = User.follow(follower, user)
1026
1027       object = insert(:note, user: user)
1028       activity = insert(:note_activity, user: user, note: object)
1029
1030       object_two = insert(:note, user: follower)
1031       activity_two = insert(:note_activity, user: follower, note: object_two)
1032
1033       {:ok, like, _} = CommonAPI.favorite(activity_two.id, user)
1034       {:ok, like_two, _} = CommonAPI.favorite(activity.id, follower)
1035       {:ok, repeat, _} = CommonAPI.repeat(activity_two.id, user)
1036
1037       {:ok, job} = User.delete(user)
1038       {:ok, _user} = ObanHelpers.perform(job)
1039
1040       follower = User.get_cached_by_id(follower.id)
1041
1042       refute User.following?(follower, user)
1043       refute User.get_by_id(user.id)
1044       assert {:ok, nil} == Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1045
1046       user_activities =
1047         user.ap_id
1048         |> Activity.Queries.by_actor()
1049         |> Repo.all()
1050         |> Enum.map(fn act -> act.data["type"] end)
1051
1052       assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)
1053
1054       refute Activity.get_by_id(activity.id)
1055       refute Activity.get_by_id(like.id)
1056       refute Activity.get_by_id(like_two.id)
1057       refute Activity.get_by_id(repeat.id)
1058     end
1059
1060     test_with_mock "it sends out User Delete activity",
1061                    %{user: user},
1062                    Pleroma.Web.ActivityPub.Publisher,
1063                    [:passthrough],
1064                    [] do
1065       Pleroma.Config.put([:instance, :federating], true)
1066
1067       {:ok, follower} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
1068       {:ok, _} = User.follow(follower, user)
1069
1070       {:ok, job} = User.delete(user)
1071       {:ok, _user} = ObanHelpers.perform(job)
1072
1073       assert ObanHelpers.member?(
1074                %{
1075                  "op" => "publish_one",
1076                  "params" => %{
1077                    "inbox" => "http://mastodon.example.org/inbox",
1078                    "id" => "pleroma:fakeid"
1079                  }
1080                },
1081                all_enqueued(worker: Pleroma.Workers.PublisherWorker)
1082              )
1083     end
1084   end
1085
1086   test "get_public_key_for_ap_id fetches a user that's not in the db" do
1087     assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
1088   end
1089
1090   describe "insert or update a user from given data" do
1091     test "with normal data" do
1092       user = insert(:user, %{nickname: "nick@name.de"})
1093       data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}
1094
1095       assert {:ok, %User{}} = User.insert_or_update_user(data)
1096     end
1097
1098     test "with overly long fields" do
1099       current_max_length = Pleroma.Config.get([:instance, :account_field_value_length], 255)
1100       user = insert(:user, nickname: "nickname@supergood.domain")
1101
1102       data = %{
1103         ap_id: user.ap_id,
1104         name: user.name,
1105         nickname: user.nickname,
1106         info: %{
1107           fields: [
1108             %{"name" => "myfield", "value" => String.duplicate("h", current_max_length + 1)}
1109           ]
1110         }
1111       }
1112
1113       assert {:ok, %User{}} = User.insert_or_update_user(data)
1114     end
1115
1116     test "with an overly long bio" do
1117       current_max_length = Pleroma.Config.get([:instance, :user_bio_length], 5000)
1118       user = insert(:user, nickname: "nickname@supergood.domain")
1119
1120       data = %{
1121         ap_id: user.ap_id,
1122         name: user.name,
1123         nickname: user.nickname,
1124         bio: String.duplicate("h", current_max_length + 1),
1125         info: %{}
1126       }
1127
1128       assert {:ok, %User{}} = User.insert_or_update_user(data)
1129     end
1130
1131     test "with an overly long display name" do
1132       current_max_length = Pleroma.Config.get([:instance, :user_name_length], 100)
1133       user = insert(:user, nickname: "nickname@supergood.domain")
1134
1135       data = %{
1136         ap_id: user.ap_id,
1137         name: String.duplicate("h", current_max_length + 1),
1138         nickname: user.nickname,
1139         info: %{}
1140       }
1141
1142       assert {:ok, %User{}} = User.insert_or_update_user(data)
1143     end
1144   end
1145
1146   describe "per-user rich-text filtering" do
1147     test "html_filter_policy returns default policies, when rich-text is enabled" do
1148       user = insert(:user)
1149
1150       assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
1151     end
1152
1153     test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
1154       user = insert(:user, %{info: %{no_rich_text: true}})
1155
1156       assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
1157     end
1158   end
1159
1160   describe "caching" do
1161     test "invalidate_cache works" do
1162       user = insert(:user)
1163       _user_info = User.get_cached_user_info(user)
1164
1165       User.invalidate_cache(user)
1166
1167       {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1168       {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
1169       {:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
1170     end
1171
1172     test "User.delete() plugs any possible zombie objects" do
1173       user = insert(:user)
1174
1175       {:ok, job} = User.delete(user)
1176       {:ok, _} = ObanHelpers.perform(job)
1177
1178       {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1179
1180       assert cached_user != user
1181
1182       {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")
1183
1184       assert cached_user != user
1185     end
1186   end
1187
1188   test "auth_active?/1 works correctly" do
1189     Pleroma.Config.put([:instance, :account_activation_required], true)
1190
1191     local_user = insert(:user, local: true, info: %{confirmation_pending: true})
1192     confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
1193     remote_user = insert(:user, local: false)
1194
1195     refute User.auth_active?(local_user)
1196     assert User.auth_active?(confirmed_user)
1197     assert User.auth_active?(remote_user)
1198   end
1199
1200   describe "superuser?/1" do
1201     test "returns false for unprivileged users" do
1202       user = insert(:user, local: true)
1203
1204       refute User.superuser?(user)
1205     end
1206
1207     test "returns false for remote users" do
1208       user = insert(:user, local: false)
1209       remote_admin_user = insert(:user, local: false, info: %{is_admin: true})
1210
1211       refute User.superuser?(user)
1212       refute User.superuser?(remote_admin_user)
1213     end
1214
1215     test "returns true for local moderators" do
1216       user = insert(:user, local: true, info: %{is_moderator: true})
1217
1218       assert User.superuser?(user)
1219     end
1220
1221     test "returns true for local admins" do
1222       user = insert(:user, local: true, info: %{is_admin: true})
1223
1224       assert User.superuser?(user)
1225     end
1226   end
1227
1228   describe "visible_for?/2" do
1229     test "returns true when the account is itself" do
1230       user = insert(:user, local: true)
1231
1232       assert User.visible_for?(user, user)
1233     end
1234
1235     test "returns false when the account is unauthenticated and auth is required" do
1236       Pleroma.Config.put([:instance, :account_activation_required], true)
1237
1238       user = insert(:user, local: true, info: %{confirmation_pending: true})
1239       other_user = insert(:user, local: true)
1240
1241       refute User.visible_for?(user, other_user)
1242     end
1243
1244     test "returns true when the account is unauthenticated and auth is not required" do
1245       user = insert(:user, local: true, info: %{confirmation_pending: true})
1246       other_user = insert(:user, local: true)
1247
1248       assert User.visible_for?(user, other_user)
1249     end
1250
1251     test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
1252       Pleroma.Config.put([:instance, :account_activation_required], true)
1253
1254       user = insert(:user, local: true, info: %{confirmation_pending: true})
1255       other_user = insert(:user, local: true, info: %{is_admin: true})
1256
1257       assert User.visible_for?(user, other_user)
1258     end
1259   end
1260
1261   describe "parse_bio/2" do
1262     test "preserves hosts in user links text" do
1263       remote_user = insert(:user, local: false, nickname: "nick@domain.com")
1264       user = insert(:user)
1265       bio = "A.k.a. @nick@domain.com"
1266
1267       expected_text =
1268         ~s(A.k.a. <span class="h-card"><a data-user="#{remote_user.id}" class="u-url mention" href="#{
1269           remote_user.ap_id
1270         }" rel="ugc">@<span>nick@domain.com</span></a></span>)
1271
1272       assert expected_text == User.parse_bio(bio, user)
1273     end
1274
1275     test "Adds rel=me on linkbacked urls" do
1276       user = insert(:user, ap_id: "https://social.example.org/users/lain")
1277
1278       bio = "http://example.com/rel_me/null"
1279       expected_text = "<a href=\"#{bio}\">#{bio}</a>"
1280       assert expected_text == User.parse_bio(bio, user)
1281
1282       bio = "http://example.com/rel_me/link"
1283       expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
1284       assert expected_text == User.parse_bio(bio, user)
1285
1286       bio = "http://example.com/rel_me/anchor"
1287       expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
1288       assert expected_text == User.parse_bio(bio, user)
1289     end
1290   end
1291
1292   test "follower count is updated when a follower is blocked" do
1293     user = insert(:user)
1294     follower = insert(:user)
1295     follower2 = insert(:user)
1296     follower3 = insert(:user)
1297
1298     {:ok, follower} = User.follow(follower, user)
1299     {:ok, _follower2} = User.follow(follower2, user)
1300     {:ok, _follower3} = User.follow(follower3, user)
1301
1302     {:ok, user} = User.block(user, follower)
1303
1304     assert User.user_info(user).follower_count == 2
1305   end
1306
1307   describe "list_inactive_users_query/1" do
1308     defp days_ago(days) do
1309       NaiveDateTime.add(
1310         NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
1311         -days * 60 * 60 * 24,
1312         :second
1313       )
1314     end
1315
1316     test "Users are inactive by default" do
1317       total = 10
1318
1319       users =
1320         Enum.map(1..total, fn _ ->
1321           insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
1322         end)
1323
1324       inactive_users_ids =
1325         Pleroma.User.list_inactive_users_query()
1326         |> Pleroma.Repo.all()
1327         |> Enum.map(& &1.id)
1328
1329       Enum.each(users, fn user ->
1330         assert user.id in inactive_users_ids
1331       end)
1332     end
1333
1334     test "Only includes users who has no recent activity" do
1335       total = 10
1336
1337       users =
1338         Enum.map(1..total, fn _ ->
1339           insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
1340         end)
1341
1342       {inactive, active} = Enum.split(users, trunc(total / 2))
1343
1344       Enum.map(active, fn user ->
1345         to = Enum.random(users -- [user])
1346
1347         {:ok, _} =
1348           CommonAPI.post(user, %{
1349             "status" => "hey @#{to.nickname}"
1350           })
1351       end)
1352
1353       inactive_users_ids =
1354         Pleroma.User.list_inactive_users_query()
1355         |> Pleroma.Repo.all()
1356         |> Enum.map(& &1.id)
1357
1358       Enum.each(active, fn user ->
1359         refute user.id in inactive_users_ids
1360       end)
1361
1362       Enum.each(inactive, fn user ->
1363         assert user.id in inactive_users_ids
1364       end)
1365     end
1366
1367     test "Only includes users with no read notifications" do
1368       total = 10
1369
1370       users =
1371         Enum.map(1..total, fn _ ->
1372           insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
1373         end)
1374
1375       [sender | recipients] = users
1376       {inactive, active} = Enum.split(recipients, trunc(total / 2))
1377
1378       Enum.each(recipients, fn to ->
1379         {:ok, _} =
1380           CommonAPI.post(sender, %{
1381             "status" => "hey @#{to.nickname}"
1382           })
1383
1384         {:ok, _} =
1385           CommonAPI.post(sender, %{
1386             "status" => "hey again @#{to.nickname}"
1387           })
1388       end)
1389
1390       Enum.each(active, fn user ->
1391         [n1, _n2] = Pleroma.Notification.for_user(user)
1392         {:ok, _} = Pleroma.Notification.read_one(user, n1.id)
1393       end)
1394
1395       inactive_users_ids =
1396         Pleroma.User.list_inactive_users_query()
1397         |> Pleroma.Repo.all()
1398         |> Enum.map(& &1.id)
1399
1400       Enum.each(active, fn user ->
1401         refute user.id in inactive_users_ids
1402       end)
1403
1404       Enum.each(inactive, fn user ->
1405         assert user.id in inactive_users_ids
1406       end)
1407     end
1408   end
1409
1410   describe "toggle_confirmation/1" do
1411     test "if user is confirmed" do
1412       user = insert(:user, info: %{confirmation_pending: false})
1413       {:ok, user} = User.toggle_confirmation(user)
1414
1415       assert user.info.confirmation_pending
1416       assert user.info.confirmation_token
1417     end
1418
1419     test "if user is unconfirmed" do
1420       user = insert(:user, info: %{confirmation_pending: true, confirmation_token: "some token"})
1421       {:ok, user} = User.toggle_confirmation(user)
1422
1423       refute user.info.confirmation_pending
1424       refute user.info.confirmation_token
1425     end
1426   end
1427
1428   describe "ensure_keys_present" do
1429     test "it creates keys for a user and stores them in info" do
1430       user = insert(:user)
1431       refute is_binary(user.keys)
1432       {:ok, user} = User.ensure_keys_present(user)
1433       assert is_binary(user.keys)
1434     end
1435
1436     test "it doesn't create keys if there already are some" do
1437       user = insert(:user, keys: "xxx")
1438       {:ok, user} = User.ensure_keys_present(user)
1439       assert user.keys == "xxx"
1440     end
1441   end
1442
1443   describe "get_ap_ids_by_nicknames" do
1444     test "it returns a list of AP ids for a given set of nicknames" do
1445       user = insert(:user)
1446       user_two = insert(:user)
1447
1448       ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
1449       assert length(ap_ids) == 2
1450       assert user.ap_id in ap_ids
1451       assert user_two.ap_id in ap_ids
1452     end
1453   end
1454
1455   describe "sync followers count" do
1456     setup do
1457       user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
1458       user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
1459       insert(:user, local: true)
1460       insert(:user, local: false, info: %{deactivated: true})
1461       {:ok, user1: user1, user2: user2}
1462     end
1463
1464     test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
1465       [fdb_user1] = User.external_users(limit: 1)
1466
1467       assert fdb_user1.ap_id
1468       assert fdb_user1.ap_id == user1.ap_id
1469       assert fdb_user1.id == user1.id
1470
1471       [fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)
1472
1473       assert fdb_user2.ap_id
1474       assert fdb_user2.ap_id == user2.ap_id
1475       assert fdb_user2.id == user2.id
1476
1477       assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
1478     end
1479   end
1480
1481   describe "set_info_cache/2" do
1482     setup do
1483       user = insert(:user)
1484       {:ok, user: user}
1485     end
1486
1487     test "update from args", %{user: user} do
1488       User.set_info_cache(user, %{following_count: 15, follower_count: 18})
1489
1490       %{follower_count: followers, following_count: following} = User.get_cached_user_info(user)
1491       assert followers == 18
1492       assert following == 15
1493     end
1494
1495     test "without args", %{user: user} do
1496       User.set_info_cache(user, %{})
1497
1498       %{follower_count: followers, following_count: following} = User.get_cached_user_info(user)
1499       assert followers == 0
1500       assert following == 0
1501     end
1502   end
1503
1504   describe "user_info/2" do
1505     setup do
1506       user = insert(:user)
1507       {:ok, user: user}
1508     end
1509
1510     test "update from args", %{user: user} do
1511       %{follower_count: followers, following_count: following} =
1512         User.user_info(user, %{following_count: 15, follower_count: 18})
1513
1514       assert followers == 18
1515       assert following == 15
1516     end
1517
1518     test "without args", %{user: user} do
1519       %{follower_count: followers, following_count: following} = User.user_info(user)
1520
1521       assert followers == 0
1522       assert following == 0
1523     end
1524   end
1525
1526   describe "is_internal_user?/1" do
1527     test "non-internal user returns false" do
1528       user = insert(:user)
1529       refute User.is_internal_user?(user)
1530     end
1531
1532     test "user with no nickname returns true" do
1533       user = insert(:user, %{nickname: nil})
1534       assert User.is_internal_user?(user)
1535     end
1536
1537     test "user with internal-prefixed nickname returns true" do
1538       user = insert(:user, %{nickname: "internal.test"})
1539       assert User.is_internal_user?(user)
1540     end
1541   end
1542
1543   describe "update_and_set_cache/1" do
1544     test "returns error when user is stale instead Ecto.StaleEntryError" do
1545       user = insert(:user)
1546
1547       changeset = Ecto.Changeset.change(user, bio: "test")
1548
1549       Repo.delete(user)
1550
1551       assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
1552                User.update_and_set_cache(changeset)
1553     end
1554
1555     test "performs update cache if user updated" do
1556       user = insert(:user)
1557       assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1558
1559       changeset = Ecto.Changeset.change(user, bio: "test-bio")
1560
1561       assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
1562       assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1563       assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
1564     end
1565   end
1566
1567   describe "following/followers synchronization" do
1568     clear_config([:instance, :external_user_synchronization])
1569
1570     test "updates the counters normally on following/getting a follow when disabled" do
1571       Pleroma.Config.put([:instance, :external_user_synchronization], false)
1572       user = insert(:user)
1573
1574       other_user =
1575         insert(:user,
1576           local: false,
1577           follower_address: "http://localhost:4001/users/masto_closed/followers",
1578           following_address: "http://localhost:4001/users/masto_closed/following",
1579           info: %{ap_enabled: true}
1580         )
1581
1582       assert User.user_info(other_user).following_count == 0
1583       assert User.user_info(other_user).follower_count == 0
1584
1585       {:ok, user} = Pleroma.User.follow(user, other_user)
1586       other_user = Pleroma.User.get_by_id(other_user.id)
1587
1588       assert User.user_info(user).following_count == 1
1589       assert User.user_info(other_user).follower_count == 1
1590     end
1591
1592     test "syncronizes the counters with the remote instance for the followed when enabled" do
1593       Pleroma.Config.put([:instance, :external_user_synchronization], false)
1594
1595       user = insert(:user)
1596
1597       other_user =
1598         insert(:user,
1599           local: false,
1600           follower_address: "http://localhost:4001/users/masto_closed/followers",
1601           following_address: "http://localhost:4001/users/masto_closed/following",
1602           info: %{ap_enabled: true}
1603         )
1604
1605       assert User.user_info(other_user).following_count == 0
1606       assert User.user_info(other_user).follower_count == 0
1607
1608       Pleroma.Config.put([:instance, :external_user_synchronization], true)
1609       {:ok, _user} = User.follow(user, other_user)
1610       other_user = User.get_by_id(other_user.id)
1611
1612       assert User.user_info(other_user).follower_count == 437
1613     end
1614
1615     test "syncronizes the counters with the remote instance for the follower when enabled" do
1616       Pleroma.Config.put([:instance, :external_user_synchronization], false)
1617
1618       user = insert(:user)
1619
1620       other_user =
1621         insert(:user,
1622           local: false,
1623           follower_address: "http://localhost:4001/users/masto_closed/followers",
1624           following_address: "http://localhost:4001/users/masto_closed/following",
1625           info: %{ap_enabled: true}
1626         )
1627
1628       assert User.user_info(other_user).following_count == 0
1629       assert User.user_info(other_user).follower_count == 0
1630
1631       Pleroma.Config.put([:instance, :external_user_synchronization], true)
1632       {:ok, other_user} = User.follow(other_user, user)
1633
1634       assert User.user_info(other_user).following_count == 152
1635     end
1636   end
1637
1638   describe "change_email/2" do
1639     setup do
1640       [user: insert(:user)]
1641     end
1642
1643     test "blank email returns error", %{user: user} do
1644       assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
1645       assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
1646     end
1647
1648     test "non unique email returns error", %{user: user} do
1649       %{email: email} = insert(:user)
1650
1651       assert {:error, %{errors: [email: {"has already been taken", _}]}} =
1652                User.change_email(user, email)
1653     end
1654
1655     test "invalid email returns error", %{user: user} do
1656       assert {:error, %{errors: [email: {"has invalid format", _}]}} =
1657                User.change_email(user, "cofe")
1658     end
1659
1660     test "changes email", %{user: user} do
1661       assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
1662     end
1663   end
1664
1665   describe "set_password_reset_pending/2" do
1666     setup do
1667       [user: insert(:user)]
1668     end
1669
1670     test "sets password_reset_pending to true", %{user: user} do
1671       %{password_reset_pending: password_reset_pending} = user.info
1672
1673       refute password_reset_pending
1674
1675       {:ok, %{info: %{password_reset_pending: password_reset_pending}}} =
1676         User.force_password_reset(user)
1677
1678       assert password_reset_pending
1679     end
1680   end
1681
1682   test "change_info/2" do
1683     user = insert(:user)
1684     assert user.info.hide_follows == false
1685
1686     changeset = User.change_info(user, &User.Info.profile_update(&1, %{hide_follows: true}))
1687     assert changeset.changes.info.changes.hide_follows == true
1688   end
1689
1690   test "update_info/2" do
1691     user = insert(:user)
1692     assert user.info.hide_follows == false
1693
1694     assert {:ok, _} = User.update_info(user, &User.Info.profile_update(&1, %{hide_follows: true}))
1695
1696     assert %{info: %{hide_follows: true}} = Repo.get(User, user.id)
1697     assert {:ok, %{info: %{hide_follows: true}}} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1698   end
1699
1700   describe "get_cached_by_nickname_or_id" do
1701     setup do
1702       limit_to_local_content = Pleroma.Config.get([:instance, :limit_to_local_content])
1703       local_user = insert(:user)
1704       remote_user = insert(:user, nickname: "nickname@example.com", local: false)
1705
1706       on_exit(fn ->
1707         Pleroma.Config.put([:instance, :limit_to_local_content], limit_to_local_content)
1708       end)
1709
1710       [local_user: local_user, remote_user: remote_user]
1711     end
1712
1713     test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
1714       remote_user: remote_user
1715     } do
1716       Pleroma.Config.put([:instance, :limit_to_local_content], false)
1717       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
1718
1719       Pleroma.Config.put([:instance, :limit_to_local_content], true)
1720       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
1721
1722       Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1723       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
1724     end
1725
1726     test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
1727          %{remote_user: remote_user} do
1728       Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1729       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
1730     end
1731
1732     test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
1733          %{remote_user: remote_user, local_user: local_user} do
1734       Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1735       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
1736     end
1737
1738     test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
1739          %{remote_user: remote_user} do
1740       Pleroma.Config.put([:instance, :limit_to_local_content], true)
1741       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
1742     end
1743
1744     test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
1745          %{local_user: local_user} do
1746       Pleroma.Config.put([:instance, :limit_to_local_content], false)
1747       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
1748
1749       Pleroma.Config.put([:instance, :limit_to_local_content], true)
1750       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
1751
1752       Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1753       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
1754     end
1755   end
1756 end