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