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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.UserTest do
   6   alias Pleroma.Builders.UserBuilder
   7   alias Pleroma.{User, Repo, Activity}
   8   alias Pleroma.Web.CommonAPI
   9   use Pleroma.DataCase
  10
  11   import Pleroma.Factory
  12
  13   setup_all do
  14     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  15     :ok
  16   end
  17
  18   describe "when tags are nil" do
  19     test "tagging a user" do
  20       user = insert(:user, %{tags: nil})
  21       user = User.tag(user, ["cool", "dude"])
  22
  23       assert "cool" in user.tags
  24       assert "dude" in user.tags
  25     end
  26
  27     test "untagging a user" do
  28       user = insert(:user, %{tags: nil})
  29       user = User.untag(user, ["cool", "dude"])
  30
  31       assert user.tags == []
  32     end
  33   end
  34
  35   test "ap_id returns the activity pub id for the user" do
  36     user = UserBuilder.build()
  37
  38     expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
  39
  40     assert expected_ap_id == User.ap_id(user)
  41   end
  42
  43   test "ap_followers returns the followers collection for the user" do
  44     user = UserBuilder.build()
  45
  46     expected_followers_collection = "#{User.ap_id(user)}/followers"
  47
  48     assert expected_followers_collection == User.ap_followers(user)
  49   end
  50
  51   test "follow takes a user and another user" do
  52     user = insert(:user)
  53     followed = insert(:user)
  54
  55     {:ok, user} = User.follow(user, followed)
  56
  57     user = Repo.get(User, user.id)
  58
  59     followed = User.get_by_ap_id(followed.ap_id)
  60     assert followed.info.follower_count == 1
  61
  62     assert User.ap_followers(followed) in user.following
  63   end
  64
  65   test "can't follow a deactivated users" do
  66     user = insert(:user)
  67     followed = insert(:user, info: %{deactivated: true})
  68
  69     {:error, _} = User.follow(user, followed)
  70   end
  71
  72   test "can't follow a user who blocked us" do
  73     blocker = insert(:user)
  74     blockee = insert(:user)
  75
  76     {:ok, blocker} = User.block(blocker, blockee)
  77
  78     {:error, _} = User.follow(blockee, blocker)
  79   end
  80
  81   test "local users do not automatically follow local locked accounts" do
  82     follower = insert(:user, info: %{locked: true})
  83     followed = insert(:user, info: %{locked: true})
  84
  85     {:ok, follower} = User.maybe_direct_follow(follower, followed)
  86
  87     refute User.following?(follower, followed)
  88   end
  89
  90   # This is a somewhat useless test.
  91   # test "following a remote user will ensure a websub subscription is present" do
  92   #   user = insert(:user)
  93   #   {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")
  94
  95   #   assert followed.local == false
  96
  97   #   {:ok, user} = User.follow(user, followed)
  98   #   assert User.ap_followers(followed) in user.following
  99
 100   #   query = from w in WebsubClientSubscription,
 101   #   where: w.topic == ^followed.info["topic"]
 102   #   websub = Repo.one(query)
 103
 104   #   assert websub
 105   # end
 106
 107   test "unfollow takes a user and another user" do
 108     followed = insert(:user)
 109     user = insert(:user, %{following: [User.ap_followers(followed)]})
 110
 111     {:ok, user, _activity} = User.unfollow(user, followed)
 112
 113     user = Repo.get(User, user.id)
 114
 115     assert user.following == []
 116   end
 117
 118   test "unfollow doesn't unfollow yourself" do
 119     user = insert(:user)
 120
 121     {:error, _} = User.unfollow(user, user)
 122
 123     user = Repo.get(User, user.id)
 124     assert user.following == [user.ap_id]
 125   end
 126
 127   test "test if a user is following another user" do
 128     followed = insert(:user)
 129     user = insert(:user, %{following: [User.ap_followers(followed)]})
 130
 131     assert User.following?(user, followed)
 132     refute User.following?(followed, user)
 133   end
 134
 135   describe "user registration" do
 136     @full_user_data %{
 137       bio: "A guy",
 138       name: "my name",
 139       nickname: "nick",
 140       password: "test",
 141       password_confirmation: "test",
 142       email: "email@example.com"
 143     }
 144
 145     test "it autofollows accounts that are set for it" do
 146       user = insert(:user)
 147       remote_user = insert(:user, %{local: false})
 148
 149       Pleroma.Config.put([:instance, :autofollowed_nicknames], [
 150         user.nickname,
 151         remote_user.nickname
 152       ])
 153
 154       cng = User.register_changeset(%User{}, @full_user_data)
 155
 156       {:ok, registered_user} = User.register(cng)
 157
 158       assert User.following?(registered_user, user)
 159       refute User.following?(registered_user, remote_user)
 160     end
 161
 162     test "it requires an email, name, nickname and password, bio is optional" do
 163       @full_user_data
 164       |> Map.keys()
 165       |> Enum.each(fn key ->
 166         params = Map.delete(@full_user_data, key)
 167         changeset = User.register_changeset(%User{}, params)
 168
 169         assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
 170       end)
 171     end
 172
 173     test "it restricts certain nicknames" do
 174       [restricted_name | _] = Pleroma.Config.get([Pleroma.User, :restricted_nicknames])
 175
 176       assert is_bitstring(restricted_name)
 177
 178       params =
 179         @full_user_data
 180         |> Map.put(:nickname, restricted_name)
 181
 182       changeset = User.register_changeset(%User{}, params)
 183
 184       refute changeset.valid?
 185     end
 186
 187     test "it sets the password_hash, ap_id and following fields" do
 188       changeset = User.register_changeset(%User{}, @full_user_data)
 189
 190       assert changeset.valid?
 191
 192       assert is_binary(changeset.changes[:password_hash])
 193       assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
 194
 195       assert changeset.changes[:following] == [
 196                User.ap_followers(%User{nickname: @full_user_data.nickname})
 197              ]
 198
 199       assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
 200     end
 201
 202     test "it ensures info is not nil" do
 203       changeset = User.register_changeset(%User{}, @full_user_data)
 204
 205       assert changeset.valid?
 206
 207       {:ok, user} =
 208         changeset
 209         |> Repo.insert()
 210
 211       refute is_nil(user.info)
 212     end
 213   end
 214
 215   describe "user registration, with :account_activation_required" do
 216     @full_user_data %{
 217       bio: "A guy",
 218       name: "my name",
 219       nickname: "nick",
 220       password: "test",
 221       password_confirmation: "test",
 222       email: "email@example.com"
 223     }
 224
 225     setup do
 226       setting = Pleroma.Config.get([:instance, :account_activation_required])
 227
 228       unless setting do
 229         Pleroma.Config.put([:instance, :account_activation_required], true)
 230         on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
 231       end
 232
 233       :ok
 234     end
 235
 236     test "it creates unconfirmed user" do
 237       changeset = User.register_changeset(%User{}, @full_user_data)
 238       assert changeset.valid?
 239
 240       {:ok, user} = Repo.insert(changeset)
 241
 242       assert user.info.confirmation_pending
 243       assert user.info.confirmation_token
 244     end
 245
 246     test "it creates confirmed user if :confirmed option is given" do
 247       changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
 248       assert changeset.valid?
 249
 250       {:ok, user} = Repo.insert(changeset)
 251
 252       refute user.info.confirmation_pending
 253       refute user.info.confirmation_token
 254     end
 255   end
 256
 257   describe "get_or_fetch/1" do
 258     test "gets an existing user by nickname" do
 259       user = insert(:user)
 260       fetched_user = User.get_or_fetch(user.nickname)
 261
 262       assert user == fetched_user
 263     end
 264
 265     test "gets an existing user by ap_id" do
 266       ap_id = "http://mastodon.example.org/users/admin"
 267
 268       user =
 269         insert(
 270           :user,
 271           local: false,
 272           nickname: "admin@mastodon.example.org",
 273           ap_id: ap_id,
 274           info: %{}
 275         )
 276
 277       fetched_user = User.get_or_fetch(ap_id)
 278       freshed_user = refresh_record(user)
 279       assert freshed_user == fetched_user
 280     end
 281   end
 282
 283   describe "fetching a user from nickname or trying to build one" do
 284     test "gets an existing user" do
 285       user = insert(:user)
 286       fetched_user = User.get_or_fetch_by_nickname(user.nickname)
 287
 288       assert user == fetched_user
 289     end
 290
 291     test "gets an existing user, case insensitive" do
 292       user = insert(:user, nickname: "nick")
 293       fetched_user = User.get_or_fetch_by_nickname("NICK")
 294
 295       assert user == fetched_user
 296     end
 297
 298     test "gets an existing user by fully qualified nickname" do
 299       user = insert(:user)
 300
 301       fetched_user =
 302         User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
 303
 304       assert user == fetched_user
 305     end
 306
 307     test "gets an existing user by fully qualified nickname, case insensitive" do
 308       user = insert(:user, nickname: "nick")
 309       casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
 310
 311       fetched_user = User.get_or_fetch_by_nickname(casing_altered_fqn)
 312
 313       assert user == fetched_user
 314     end
 315
 316     test "fetches an external user via ostatus if no user exists" do
 317       fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
 318       assert fetched_user.nickname == "shp@social.heldscal.la"
 319     end
 320
 321     test "returns nil if no user could be fetched" do
 322       fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
 323       assert fetched_user == nil
 324     end
 325
 326     test "returns nil for nonexistant local user" do
 327       fetched_user = User.get_or_fetch_by_nickname("nonexistant")
 328       assert fetched_user == nil
 329     end
 330
 331     test "updates an existing user, if stale" do
 332       a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
 333
 334       orig_user =
 335         insert(
 336           :user,
 337           local: false,
 338           nickname: "admin@mastodon.example.org",
 339           ap_id: "http://mastodon.example.org/users/admin",
 340           last_refreshed_at: a_week_ago,
 341           info: %{}
 342         )
 343
 344       assert orig_user.last_refreshed_at == a_week_ago
 345
 346       user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
 347       assert user.info.source_data["endpoints"]
 348
 349       refute user.last_refreshed_at == orig_user.last_refreshed_at
 350     end
 351   end
 352
 353   test "returns an ap_id for a user" do
 354     user = insert(:user)
 355
 356     assert User.ap_id(user) ==
 357              Pleroma.Web.Router.Helpers.o_status_url(
 358                Pleroma.Web.Endpoint,
 359                :feed_redirect,
 360                user.nickname
 361              )
 362   end
 363
 364   test "returns an ap_followers link for a user" do
 365     user = insert(:user)
 366
 367     assert User.ap_followers(user) ==
 368              Pleroma.Web.Router.Helpers.o_status_url(
 369                Pleroma.Web.Endpoint,
 370                :feed_redirect,
 371                user.nickname
 372              ) <> "/followers"
 373   end
 374
 375   describe "remote user creation changeset" do
 376     @valid_remote %{
 377       bio: "hello",
 378       name: "Someone",
 379       nickname: "a@b.de",
 380       ap_id: "http...",
 381       info: %{some: "info"},
 382       avatar: %{some: "avatar"}
 383     }
 384
 385     test "it confirms validity" do
 386       cs = User.remote_user_creation(@valid_remote)
 387       assert cs.valid?
 388     end
 389
 390     test "it sets the follower_adress" do
 391       cs = User.remote_user_creation(@valid_remote)
 392       # remote users get a fake local follower address
 393       assert cs.changes.follower_address ==
 394                User.ap_followers(%User{nickname: @valid_remote[:nickname]})
 395     end
 396
 397     test "it enforces the fqn format for nicknames" do
 398       cs = User.remote_user_creation(%{@valid_remote | nickname: "bla"})
 399       assert cs.changes.local == false
 400       assert cs.changes.avatar
 401       refute cs.valid?
 402     end
 403
 404     test "it has required fields" do
 405       [:name, :ap_id]
 406       |> Enum.each(fn field ->
 407         cs = User.remote_user_creation(Map.delete(@valid_remote, field))
 408         refute cs.valid?
 409       end)
 410     end
 411
 412     test "it restricts some sizes" do
 413       [bio: 5000, name: 100]
 414       |> Enum.each(fn {field, size} ->
 415         string = String.pad_leading(".", size)
 416         cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
 417         assert cs.valid?
 418
 419         string = String.pad_leading(".", size + 1)
 420         cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
 421         refute cs.valid?
 422       end)
 423     end
 424   end
 425
 426   describe "followers and friends" do
 427     test "gets all followers for a given user" do
 428       user = insert(:user)
 429       follower_one = insert(:user)
 430       follower_two = insert(:user)
 431       not_follower = insert(:user)
 432
 433       {:ok, follower_one} = User.follow(follower_one, user)
 434       {:ok, follower_two} = User.follow(follower_two, user)
 435
 436       {:ok, res} = User.get_followers(user)
 437
 438       assert Enum.member?(res, follower_one)
 439       assert Enum.member?(res, follower_two)
 440       refute Enum.member?(res, not_follower)
 441     end
 442
 443     test "gets all friends (followed users) for a given user" do
 444       user = insert(:user)
 445       followed_one = insert(:user)
 446       followed_two = insert(:user)
 447       not_followed = insert(:user)
 448
 449       {:ok, user} = User.follow(user, followed_one)
 450       {:ok, user} = User.follow(user, followed_two)
 451
 452       {:ok, res} = User.get_friends(user)
 453
 454       followed_one = User.get_by_ap_id(followed_one.ap_id)
 455       followed_two = User.get_by_ap_id(followed_two.ap_id)
 456       assert Enum.member?(res, followed_one)
 457       assert Enum.member?(res, followed_two)
 458       refute Enum.member?(res, not_followed)
 459     end
 460   end
 461
 462   describe "updating note and follower count" do
 463     test "it sets the info->note_count property" do
 464       note = insert(:note)
 465
 466       user = User.get_by_ap_id(note.data["actor"])
 467
 468       assert user.info.note_count == 0
 469
 470       {:ok, user} = User.update_note_count(user)
 471
 472       assert user.info.note_count == 1
 473     end
 474
 475     test "it increases the info->note_count property" do
 476       note = insert(:note)
 477       user = User.get_by_ap_id(note.data["actor"])
 478
 479       assert user.info.note_count == 0
 480
 481       {:ok, user} = User.increase_note_count(user)
 482
 483       assert user.info.note_count == 1
 484
 485       {:ok, user} = User.increase_note_count(user)
 486
 487       assert user.info.note_count == 2
 488     end
 489
 490     test "it decreases the info->note_count property" do
 491       note = insert(:note)
 492       user = User.get_by_ap_id(note.data["actor"])
 493
 494       assert user.info.note_count == 0
 495
 496       {:ok, user} = User.increase_note_count(user)
 497
 498       assert user.info.note_count == 1
 499
 500       {:ok, user} = User.decrease_note_count(user)
 501
 502       assert user.info.note_count == 0
 503
 504       {:ok, user} = User.decrease_note_count(user)
 505
 506       assert user.info.note_count == 0
 507     end
 508
 509     test "it sets the info->follower_count property" do
 510       user = insert(:user)
 511       follower = insert(:user)
 512
 513       User.follow(follower, user)
 514
 515       assert user.info.follower_count == 0
 516
 517       {:ok, user} = User.update_follower_count(user)
 518
 519       assert user.info.follower_count == 1
 520     end
 521   end
 522
 523   describe "follow_import" do
 524     test "it imports user followings from list" do
 525       [user1, user2, user3] = insert_list(3, :user)
 526
 527       identifiers = [
 528         user2.ap_id,
 529         user3.nickname
 530       ]
 531
 532       result = User.follow_import(user1, identifiers)
 533       assert is_list(result)
 534       assert result == [user2, user3]
 535     end
 536   end
 537
 538   describe "blocks" do
 539     test "it blocks people" do
 540       user = insert(:user)
 541       blocked_user = insert(:user)
 542
 543       refute User.blocks?(user, blocked_user)
 544
 545       {:ok, user} = User.block(user, blocked_user)
 546
 547       assert User.blocks?(user, blocked_user)
 548     end
 549
 550     test "it unblocks users" do
 551       user = insert(:user)
 552       blocked_user = insert(:user)
 553
 554       {:ok, user} = User.block(user, blocked_user)
 555       {:ok, user} = User.unblock(user, blocked_user)
 556
 557       refute User.blocks?(user, blocked_user)
 558     end
 559
 560     test "blocks tear down cyclical follow relationships" do
 561       blocker = insert(:user)
 562       blocked = insert(:user)
 563
 564       {:ok, blocker} = User.follow(blocker, blocked)
 565       {:ok, blocked} = User.follow(blocked, blocker)
 566
 567       assert User.following?(blocker, blocked)
 568       assert User.following?(blocked, blocker)
 569
 570       {:ok, blocker} = User.block(blocker, blocked)
 571       blocked = Repo.get(User, blocked.id)
 572
 573       assert User.blocks?(blocker, blocked)
 574
 575       refute User.following?(blocker, blocked)
 576       refute User.following?(blocked, blocker)
 577     end
 578
 579     test "blocks tear down blocker->blocked follow relationships" do
 580       blocker = insert(:user)
 581       blocked = insert(:user)
 582
 583       {:ok, blocker} = User.follow(blocker, blocked)
 584
 585       assert User.following?(blocker, blocked)
 586       refute User.following?(blocked, blocker)
 587
 588       {:ok, blocker} = User.block(blocker, blocked)
 589       blocked = Repo.get(User, blocked.id)
 590
 591       assert User.blocks?(blocker, blocked)
 592
 593       refute User.following?(blocker, blocked)
 594       refute User.following?(blocked, blocker)
 595     end
 596
 597     test "blocks tear down blocked->blocker follow relationships" do
 598       blocker = insert(:user)
 599       blocked = insert(:user)
 600
 601       {:ok, blocked} = User.follow(blocked, blocker)
 602
 603       refute User.following?(blocker, blocked)
 604       assert User.following?(blocked, blocker)
 605
 606       {:ok, blocker} = User.block(blocker, blocked)
 607       blocked = Repo.get(User, blocked.id)
 608
 609       assert User.blocks?(blocker, blocked)
 610
 611       refute User.following?(blocker, blocked)
 612       refute User.following?(blocked, blocker)
 613     end
 614   end
 615
 616   describe "domain blocking" do
 617     test "blocks domains" do
 618       user = insert(:user)
 619       collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
 620
 621       {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
 622
 623       assert User.blocks?(user, collateral_user)
 624     end
 625
 626     test "unblocks domains" do
 627       user = insert(:user)
 628       collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
 629
 630       {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
 631       {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")
 632
 633       refute User.blocks?(user, collateral_user)
 634     end
 635   end
 636
 637   describe "blocks_import" do
 638     test "it imports user blocks from list" do
 639       [user1, user2, user3] = insert_list(3, :user)
 640
 641       identifiers = [
 642         user2.ap_id,
 643         user3.nickname
 644       ]
 645
 646       result = User.blocks_import(user1, identifiers)
 647       assert is_list(result)
 648       assert result == [user2, user3]
 649     end
 650   end
 651
 652   test "get recipients from activity" do
 653     actor = insert(:user)
 654     user = insert(:user, local: true)
 655     user_two = insert(:user, local: false)
 656     addressed = insert(:user, local: true)
 657     addressed_remote = insert(:user, local: false)
 658
 659     {:ok, activity} =
 660       CommonAPI.post(actor, %{
 661         "status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
 662       })
 663
 664     assert [addressed] == User.get_recipients_from_activity(activity)
 665
 666     {:ok, user} = User.follow(user, actor)
 667     {:ok, _user_two} = User.follow(user_two, actor)
 668     recipients = User.get_recipients_from_activity(activity)
 669     assert length(recipients) == 2
 670     assert user in recipients
 671     assert addressed in recipients
 672   end
 673
 674   test ".deactivate can de-activate then re-activate a user" do
 675     user = insert(:user)
 676     assert false == user.info.deactivated
 677     {:ok, user} = User.deactivate(user)
 678     assert true == user.info.deactivated
 679     {:ok, user} = User.deactivate(user, false)
 680     assert false == user.info.deactivated
 681   end
 682
 683   test ".delete deactivates a user, all follow relationships and all create activities" do
 684     user = insert(:user)
 685     followed = insert(:user)
 686     follower = insert(:user)
 687
 688     {:ok, user} = User.follow(user, followed)
 689     {:ok, follower} = User.follow(follower, user)
 690
 691     {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
 692     {:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})
 693
 694     {:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
 695     {:ok, _, _} = CommonAPI.favorite(activity.id, follower)
 696     {:ok, _, _} = CommonAPI.repeat(activity.id, follower)
 697
 698     {:ok, _} = User.delete(user)
 699
 700     followed = Repo.get(User, followed.id)
 701     follower = Repo.get(User, follower.id)
 702     user = Repo.get(User, user.id)
 703
 704     assert user.info.deactivated
 705
 706     refute User.following?(user, followed)
 707     refute User.following?(followed, follower)
 708
 709     # TODO: Remove favorites, repeats, delete activities.
 710
 711     refute Repo.get(Activity, activity.id)
 712   end
 713
 714   test "get_public_key_for_ap_id fetches a user that's not in the db" do
 715     assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
 716   end
 717
 718   test "insert or update a user from given data" do
 719     user = insert(:user, %{nickname: "nick@name.de"})
 720     data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}
 721
 722     assert {:ok, %User{}} = User.insert_or_update_user(data)
 723   end
 724
 725   describe "per-user rich-text filtering" do
 726     test "html_filter_policy returns default policies, when rich-text is enabled" do
 727       user = insert(:user)
 728
 729       assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
 730     end
 731
 732     test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
 733       user = insert(:user, %{info: %{no_rich_text: true}})
 734
 735       assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
 736     end
 737   end
 738
 739   describe "caching" do
 740     test "invalidate_cache works" do
 741       user = insert(:user)
 742       _user_info = User.get_cached_user_info(user)
 743
 744       User.invalidate_cache(user)
 745
 746       {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
 747       {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
 748       {:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
 749     end
 750
 751     test "User.delete() plugs any possible zombie objects" do
 752       user = insert(:user)
 753
 754       {:ok, _} = User.delete(user)
 755
 756       {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
 757
 758       assert cached_user != user
 759
 760       {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")
 761
 762       assert cached_user != user
 763     end
 764   end
 765
 766   describe "User.search" do
 767     test "finds a user, ranking by similarity" do
 768       _user = insert(:user, %{name: "lain"})
 769       _user_two = insert(:user, %{name: "ean"})
 770       _user_three = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
 771       user_four = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})
 772
 773       assert user_four ==
 774                User.search("lain@ple") |> List.first() |> Map.put(:search_distance, nil)
 775     end
 776
 777     test "finds a user whose name is nil" do
 778       _user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
 779       user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})
 780
 781       assert user_two ==
 782                User.search("lain@pleroma.soykaf.com")
 783                |> List.first()
 784                |> Map.put(:search_distance, nil)
 785     end
 786   end
 787
 788   test "auth_active?/1 works correctly" do
 789     Pleroma.Config.put([:instance, :account_activation_required], true)
 790
 791     local_user = insert(:user, local: true, info: %{confirmation_pending: true})
 792     confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
 793     remote_user = insert(:user, local: false)
 794
 795     refute User.auth_active?(local_user)
 796     assert User.auth_active?(confirmed_user)
 797     assert User.auth_active?(remote_user)
 798
 799     Pleroma.Config.put([:instance, :account_activation_required], false)
 800   end
 801
 802   describe "superuser?/1" do
 803     test "returns false for unprivileged users" do
 804       user = insert(:user, local: true)
 805
 806       refute User.superuser?(user)
 807     end
 808
 809     test "returns false for remote users" do
 810       user = insert(:user, local: false)
 811       remote_admin_user = insert(:user, local: false, info: %{is_admin: true})
 812
 813       refute User.superuser?(user)
 814       refute User.superuser?(remote_admin_user)
 815     end
 816
 817     test "returns true for local moderators" do
 818       user = insert(:user, local: true, info: %{is_moderator: true})
 819
 820       assert User.superuser?(user)
 821     end
 822
 823     test "returns true for local admins" do
 824       user = insert(:user, local: true, info: %{is_admin: true})
 825
 826       assert User.superuser?(user)
 827     end
 828   end
 829
 830   describe "visible_for?/2" do
 831     test "returns true when the account is itself" do
 832       user = insert(:user, local: true)
 833
 834       assert User.visible_for?(user, user)
 835     end
 836
 837     test "returns false when the account is unauthenticated and auth is required" do
 838       Pleroma.Config.put([:instance, :account_activation_required], true)
 839
 840       user = insert(:user, local: true, info: %{confirmation_pending: true})
 841       other_user = insert(:user, local: true)
 842
 843       refute User.visible_for?(user, other_user)
 844
 845       Pleroma.Config.put([:instance, :account_activation_required], false)
 846     end
 847
 848     test "returns true when the account is unauthenticated and auth is not required" do
 849       user = insert(:user, local: true, info: %{confirmation_pending: true})
 850       other_user = insert(:user, local: true)
 851
 852       assert User.visible_for?(user, other_user)
 853     end
 854
 855     test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
 856       Pleroma.Config.put([:instance, :account_activation_required], true)
 857
 858       user = insert(:user, local: true, info: %{confirmation_pending: true})
 859       other_user = insert(:user, local: true, info: %{is_admin: true})
 860
 861       assert User.visible_for?(user, other_user)
 862
 863       Pleroma.Config.put([:instance, :account_activation_required], false)
 864     end
 865   end
 866 end