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