1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.UserTest do
7 alias Pleroma.Builders.UserBuilder
10 alias Pleroma.Tests.ObanHelpers
12 alias Pleroma.Web.ActivityPub.ActivityPub
13 alias Pleroma.Web.CommonAPI
16 use Oban.Testing, repo: Pleroma.Repo
19 import Pleroma.Factory
22 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
26 clear_config([:instance, :account_activation_required])
28 describe "when tags are nil" do
29 test "tagging a user" do
30 user = insert(:user, %{tags: nil})
31 user = User.tag(user, ["cool", "dude"])
33 assert "cool" in user.tags
34 assert "dude" in user.tags
37 test "untagging a user" do
38 user = insert(:user, %{tags: nil})
39 user = User.untag(user, ["cool", "dude"])
41 assert user.tags == []
45 test "ap_id returns the activity pub id for the user" do
46 user = UserBuilder.build()
48 expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
50 assert expected_ap_id == User.ap_id(user)
53 test "ap_followers returns the followers collection for the user" do
54 user = UserBuilder.build()
56 expected_followers_collection = "#{User.ap_id(user)}/followers"
58 assert expected_followers_collection == User.ap_followers(user)
61 test "ap_following returns the following collection for the user" do
62 user = UserBuilder.build()
64 expected_followers_collection = "#{User.ap_id(user)}/following"
66 assert expected_followers_collection == User.ap_following(user)
69 test "returns all pending follow requests" do
70 unlocked = insert(:user)
71 locked = insert(:user, %{info: %{locked: true}})
72 follower = insert(:user)
74 CommonAPI.follow(follower, unlocked)
75 CommonAPI.follow(follower, locked)
77 assert [] = User.get_follow_requests(unlocked)
78 assert [activity] = User.get_follow_requests(locked)
83 test "doesn't return already accepted or duplicate follow requests" do
84 locked = insert(:user, %{info: %{locked: true}})
85 pending_follower = insert(:user)
86 accepted_follower = insert(:user)
88 CommonAPI.follow(pending_follower, locked)
89 CommonAPI.follow(pending_follower, locked)
90 CommonAPI.follow(accepted_follower, locked)
91 User.follow(accepted_follower, locked)
93 assert [activity] = User.get_follow_requests(locked)
97 test "clears follow requests when requester is blocked" do
98 followed = insert(:user, %{info: %{locked: true}})
99 follower = insert(:user)
101 CommonAPI.follow(follower, followed)
102 assert [_activity] = User.get_follow_requests(followed)
104 {:ok, _follower} = User.block(followed, follower)
105 assert [] = User.get_follow_requests(followed)
108 test "follow_all follows mutliple users" do
110 followed_zero = insert(:user)
111 followed_one = insert(:user)
112 followed_two = insert(:user)
113 blocked = insert(:user)
114 not_followed = insert(:user)
115 reverse_blocked = insert(:user)
117 {:ok, user} = User.block(user, blocked)
118 {:ok, reverse_blocked} = User.block(reverse_blocked, user)
120 {:ok, user} = User.follow(user, followed_zero)
122 {:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])
124 assert User.following?(user, followed_one)
125 assert User.following?(user, followed_two)
126 assert User.following?(user, followed_zero)
127 refute User.following?(user, not_followed)
128 refute User.following?(user, blocked)
129 refute User.following?(user, reverse_blocked)
132 test "follow_all follows mutliple users without duplicating" do
134 followed_zero = insert(:user)
135 followed_one = insert(:user)
136 followed_two = insert(:user)
138 {:ok, user} = User.follow_all(user, [followed_zero, followed_one])
139 assert length(user.following) == 3
141 {:ok, user} = User.follow_all(user, [followed_one, followed_two])
142 assert length(user.following) == 4
145 test "follow takes a user and another user" do
147 followed = insert(:user)
149 {:ok, user} = User.follow(user, followed)
151 user = User.get_cached_by_id(user.id)
153 followed = User.get_cached_by_ap_id(followed.ap_id)
154 assert followed.info.follower_count == 1
156 assert User.ap_followers(followed) in user.following
159 test "can't follow a deactivated users" do
161 followed = insert(:user, info: %{deactivated: true})
163 {:error, _} = User.follow(user, followed)
166 test "can't follow a user who blocked us" do
167 blocker = insert(:user)
168 blockee = insert(:user)
170 {:ok, blocker} = User.block(blocker, blockee)
172 {:error, _} = User.follow(blockee, blocker)
175 test "can't subscribe to a user who blocked us" do
176 blocker = insert(:user)
177 blocked = insert(:user)
179 {:ok, blocker} = User.block(blocker, blocked)
181 {:error, _} = User.subscribe(blocked, blocker)
184 test "local users do not automatically follow local locked accounts" do
185 follower = insert(:user, info: %{locked: true})
186 followed = insert(:user, info: %{locked: true})
188 {:ok, follower} = User.maybe_direct_follow(follower, followed)
190 refute User.following?(follower, followed)
193 describe "unfollow/2" do
195 setting = Pleroma.Config.get([:instance, :external_user_synchronization])
198 Pleroma.Config.put([:instance, :external_user_synchronization], setting)
204 test "unfollow with syncronizes external user" do
205 Pleroma.Config.put([:instance, :external_user_synchronization], true)
210 follower_address: "http://localhost:4001/users/fuser1/followers",
211 following_address: "http://localhost:4001/users/fuser1/following",
212 ap_id: "http://localhost:4001/users/fuser1"
219 ap_id: "http://localhost:4001/users/fuser2",
220 follower_address: "http://localhost:4001/users/fuser2/followers",
221 following_address: "http://localhost:4001/users/fuser2/following",
222 following: [User.ap_followers(followed)]
225 {:ok, user, _activity} = User.unfollow(user, followed)
227 user = User.get_cached_by_id(user.id)
229 assert user.following == []
232 test "unfollow takes a user and another user" do
233 followed = insert(:user)
234 user = insert(:user, %{following: [User.ap_followers(followed)]})
236 {:ok, user, _activity} = User.unfollow(user, followed)
238 user = User.get_cached_by_id(user.id)
240 assert user.following == []
243 test "unfollow doesn't unfollow yourself" do
246 {:error, _} = User.unfollow(user, user)
248 user = User.get_cached_by_id(user.id)
249 assert user.following == [user.ap_id]
253 test "test if a user is following another user" do
254 followed = insert(:user)
255 user = insert(:user, %{following: [User.ap_followers(followed)]})
257 assert User.following?(user, followed)
258 refute User.following?(followed, user)
261 test "fetches correct profile for nickname beginning with number" do
262 # Use old-style integer ID to try to reproduce the problem
263 user = insert(:user, %{id: 1080})
264 user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
265 assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
268 describe "user registration" do
274 password_confirmation: "test",
275 email: "email@example.com"
277 clear_config([:instance, :autofollowed_nicknames])
278 clear_config([:instance, :welcome_message])
279 clear_config([:instance, :welcome_user_nickname])
281 test "it autofollows accounts that are set for it" do
283 remote_user = insert(:user, %{local: false})
285 Pleroma.Config.put([:instance, :autofollowed_nicknames], [
290 cng = User.register_changeset(%User{}, @full_user_data)
292 {:ok, registered_user} = User.register(cng)
294 assert User.following?(registered_user, user)
295 refute User.following?(registered_user, remote_user)
298 test "it sends a welcome message if it is set" do
299 welcome_user = insert(:user)
301 Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
302 Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")
304 cng = User.register_changeset(%User{}, @full_user_data)
305 {:ok, registered_user} = User.register(cng)
307 activity = Repo.one(Pleroma.Activity)
308 assert registered_user.ap_id in activity.recipients
309 assert Object.normalize(activity).data["content"] =~ "cool site"
310 assert activity.actor == welcome_user.ap_id
313 test "it requires an email, name, nickname and password, bio is optional" do
316 |> Enum.each(fn key ->
317 params = Map.delete(@full_user_data, key)
318 changeset = User.register_changeset(%User{}, params)
320 assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
324 test "it restricts certain nicknames" do
325 [restricted_name | _] = Pleroma.Config.get([User, :restricted_nicknames])
327 assert is_bitstring(restricted_name)
331 |> Map.put(:nickname, restricted_name)
333 changeset = User.register_changeset(%User{}, params)
335 refute changeset.valid?
338 test "it sets the password_hash, ap_id and following fields" do
339 changeset = User.register_changeset(%User{}, @full_user_data)
341 assert changeset.valid?
343 assert is_binary(changeset.changes[:password_hash])
344 assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
346 assert changeset.changes[:following] == [
347 User.ap_followers(%User{nickname: @full_user_data.nickname})
350 assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
353 test "it ensures info is not nil" do
354 changeset = User.register_changeset(%User{}, @full_user_data)
356 assert changeset.valid?
362 refute is_nil(user.info)
366 describe "user registration, with :account_activation_required" do
372 password_confirmation: "test",
373 email: "email@example.com"
376 clear_config([:instance, :account_activation_required]) do
377 Pleroma.Config.put([:instance, :account_activation_required], true)
380 test "it creates unconfirmed user" do
381 changeset = User.register_changeset(%User{}, @full_user_data)
382 assert changeset.valid?
384 {:ok, user} = Repo.insert(changeset)
386 assert user.info.confirmation_pending
387 assert user.info.confirmation_token
390 test "it creates confirmed user if :confirmed option is given" do
391 changeset = User.register_changeset(%User{}, @full_user_data, need_confirmation: false)
392 assert changeset.valid?
394 {:ok, user} = Repo.insert(changeset)
396 refute user.info.confirmation_pending
397 refute user.info.confirmation_token
401 describe "get_or_fetch/1" do
402 test "gets an existing user by nickname" do
404 {:ok, fetched_user} = User.get_or_fetch(user.nickname)
406 assert user == fetched_user
409 test "gets an existing user by ap_id" do
410 ap_id = "http://mastodon.example.org/users/admin"
416 nickname: "admin@mastodon.example.org",
421 {:ok, fetched_user} = User.get_or_fetch(ap_id)
422 freshed_user = refresh_record(user)
423 assert freshed_user == fetched_user
427 describe "fetching a user from nickname or trying to build one" do
428 test "gets an existing user" do
430 {:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)
432 assert user == fetched_user
435 test "gets an existing user, case insensitive" do
436 user = insert(:user, nickname: "nick")
437 {:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")
439 assert user == fetched_user
442 test "gets an existing user by fully qualified nickname" do
445 {:ok, fetched_user} =
446 User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
448 assert user == fetched_user
451 test "gets an existing user by fully qualified nickname, case insensitive" do
452 user = insert(:user, nickname: "nick")
453 casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
455 {:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)
457 assert user == fetched_user
460 test "fetches an external user via ostatus if no user exists" do
461 {:ok, fetched_user} = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
462 assert fetched_user.nickname == "shp@social.heldscal.la"
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"
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"
475 test "updates an existing user, if stale" do
476 a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
482 nickname: "admin@mastodon.example.org",
483 ap_id: "http://mastodon.example.org/users/admin",
484 last_refreshed_at: a_week_ago,
488 assert orig_user.last_refreshed_at == a_week_ago
490 {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
491 assert user.info.source_data["endpoints"]
493 refute user.last_refreshed_at == orig_user.last_refreshed_at
497 test "returns an ap_id for a user" do
500 assert User.ap_id(user) ==
501 Pleroma.Web.Router.Helpers.feed_url(
502 Pleroma.Web.Endpoint,
508 test "returns an ap_followers link for a user" do
511 assert User.ap_followers(user) ==
512 Pleroma.Web.Router.Helpers.feed_url(
513 Pleroma.Web.Endpoint,
519 describe "remote user creation changeset" do
525 info: %{some: "info"},
526 avatar: %{some: "avatar"}
529 clear_config([:instance, :user_bio_length])
530 clear_config([:instance, :user_name_length])
532 test "it confirms validity" do
533 cs = User.remote_user_creation(@valid_remote)
537 test "it sets the follower_adress" do
538 cs = User.remote_user_creation(@valid_remote)
539 # remote users get a fake local follower address
540 assert cs.changes.follower_address ==
541 User.ap_followers(%User{nickname: @valid_remote[:nickname]})
544 test "it enforces the fqn format for nicknames" do
545 cs = User.remote_user_creation(%{@valid_remote | nickname: "bla"})
546 assert Ecto.Changeset.get_field(cs, :local) == false
547 assert cs.changes.avatar
551 test "it has required fields" do
553 |> Enum.each(fn field ->
554 cs = User.remote_user_creation(Map.delete(@valid_remote, field))
560 describe "followers and friends" do
561 test "gets all followers for a given user" do
563 follower_one = insert(:user)
564 follower_two = insert(:user)
565 not_follower = insert(:user)
567 {:ok, follower_one} = User.follow(follower_one, user)
568 {:ok, follower_two} = User.follow(follower_two, user)
570 res = User.get_followers(user)
572 assert Enum.member?(res, follower_one)
573 assert Enum.member?(res, follower_two)
574 refute Enum.member?(res, not_follower)
577 test "gets all friends (followed users) for a given user" do
579 followed_one = insert(:user)
580 followed_two = insert(:user)
581 not_followed = insert(:user)
583 {:ok, user} = User.follow(user, followed_one)
584 {:ok, user} = User.follow(user, followed_two)
586 res = User.get_friends(user)
588 followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
589 followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
590 assert Enum.member?(res, followed_one)
591 assert Enum.member?(res, followed_two)
592 refute Enum.member?(res, not_followed)
596 describe "updating note and follower count" do
597 test "it sets the info->note_count property" do
600 user = User.get_cached_by_ap_id(note.data["actor"])
602 assert user.info.note_count == 0
604 {:ok, user} = User.update_note_count(user)
606 assert user.info.note_count == 1
609 test "it increases the info->note_count property" do
611 user = User.get_cached_by_ap_id(note.data["actor"])
613 assert user.info.note_count == 0
615 {:ok, user} = User.increase_note_count(user)
617 assert user.info.note_count == 1
619 {:ok, user} = User.increase_note_count(user)
621 assert user.info.note_count == 2
624 test "it decreases the info->note_count property" do
626 user = User.get_cached_by_ap_id(note.data["actor"])
628 assert user.info.note_count == 0
630 {:ok, user} = User.increase_note_count(user)
632 assert user.info.note_count == 1
634 {:ok, user} = User.decrease_note_count(user)
636 assert user.info.note_count == 0
638 {:ok, user} = User.decrease_note_count(user)
640 assert user.info.note_count == 0
643 test "it sets the info->follower_count property" do
645 follower = insert(:user)
647 User.follow(follower, user)
649 assert user.info.follower_count == 0
651 {:ok, user} = User.update_follower_count(user)
653 assert user.info.follower_count == 1
657 describe "remove duplicates from following list" do
658 test "it removes duplicates" do
660 follower = insert(:user)
662 {:ok, %User{following: following} = follower} = User.follow(follower, user)
663 assert length(following) == 2
667 |> User.update_changeset(%{following: following ++ following})
670 assert length(follower.following) == 4
672 {:ok, follower} = User.remove_duplicated_following(follower)
673 assert length(follower.following) == 2
676 test "it does nothing when following is uniq" do
678 follower = insert(:user)
680 {:ok, follower} = User.follow(follower, user)
681 assert length(follower.following) == 2
683 {:ok, follower} = User.remove_duplicated_following(follower)
684 assert length(follower.following) == 2
688 describe "follow_import" do
689 test "it imports user followings from list" do
690 [user1, user2, user3] = insert_list(3, :user)
697 {:ok, job} = User.follow_import(user1, identifiers)
698 result = ObanHelpers.perform(job)
700 assert is_list(result)
701 assert result == [user2, user3]
706 test "it mutes people" do
708 muted_user = insert(:user)
710 refute User.mutes?(user, muted_user)
711 refute User.muted_notifications?(user, muted_user)
713 {:ok, user} = User.mute(user, muted_user)
715 assert User.mutes?(user, muted_user)
716 assert User.muted_notifications?(user, muted_user)
719 test "it unmutes users" do
721 muted_user = insert(:user)
723 {:ok, user} = User.mute(user, muted_user)
724 {:ok, user} = User.unmute(user, muted_user)
726 refute User.mutes?(user, muted_user)
727 refute User.muted_notifications?(user, muted_user)
730 test "it mutes user without notifications" do
732 muted_user = insert(:user)
734 refute User.mutes?(user, muted_user)
735 refute User.muted_notifications?(user, muted_user)
737 {:ok, user} = User.mute(user, muted_user, false)
739 assert User.mutes?(user, muted_user)
740 refute User.muted_notifications?(user, muted_user)
745 test "it blocks people" do
747 blocked_user = insert(:user)
749 refute User.blocks?(user, blocked_user)
751 {:ok, user} = User.block(user, blocked_user)
753 assert User.blocks?(user, blocked_user)
756 test "it unblocks users" do
758 blocked_user = insert(:user)
760 {:ok, user} = User.block(user, blocked_user)
761 {:ok, user} = User.unblock(user, blocked_user)
763 refute User.blocks?(user, blocked_user)
766 test "blocks tear down cyclical follow relationships" do
767 blocker = insert(:user)
768 blocked = insert(:user)
770 {:ok, blocker} = User.follow(blocker, blocked)
771 {:ok, blocked} = User.follow(blocked, blocker)
773 assert User.following?(blocker, blocked)
774 assert User.following?(blocked, blocker)
776 {:ok, blocker} = User.block(blocker, blocked)
777 blocked = User.get_cached_by_id(blocked.id)
779 assert User.blocks?(blocker, blocked)
781 refute User.following?(blocker, blocked)
782 refute User.following?(blocked, blocker)
785 test "blocks tear down blocker->blocked follow relationships" do
786 blocker = insert(:user)
787 blocked = insert(:user)
789 {:ok, blocker} = User.follow(blocker, blocked)
791 assert User.following?(blocker, blocked)
792 refute User.following?(blocked, blocker)
794 {:ok, blocker} = User.block(blocker, blocked)
795 blocked = User.get_cached_by_id(blocked.id)
797 assert User.blocks?(blocker, blocked)
799 refute User.following?(blocker, blocked)
800 refute User.following?(blocked, blocker)
803 test "blocks tear down blocked->blocker follow relationships" do
804 blocker = insert(:user)
805 blocked = insert(:user)
807 {:ok, blocked} = User.follow(blocked, blocker)
809 refute User.following?(blocker, blocked)
810 assert User.following?(blocked, blocker)
812 {:ok, blocker} = User.block(blocker, blocked)
813 blocked = User.get_cached_by_id(blocked.id)
815 assert User.blocks?(blocker, blocked)
817 refute User.following?(blocker, blocked)
818 refute User.following?(blocked, blocker)
821 test "blocks tear down blocked->blocker subscription relationships" do
822 blocker = insert(:user)
823 blocked = insert(:user)
825 {:ok, blocker} = User.subscribe(blocked, blocker)
827 assert User.subscribed_to?(blocked, blocker)
828 refute User.subscribed_to?(blocker, blocked)
830 {:ok, blocker} = User.block(blocker, blocked)
832 assert User.blocks?(blocker, blocked)
833 refute User.subscribed_to?(blocker, blocked)
834 refute User.subscribed_to?(blocked, blocker)
838 describe "domain blocking" do
839 test "blocks domains" do
841 collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
843 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
845 assert User.blocks?(user, collateral_user)
848 test "does not block domain with same end" do
852 insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
854 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
856 refute User.blocks?(user, collateral_user)
859 test "does not block domain with same end if wildcard added" do
863 insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
865 {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
867 refute User.blocks?(user, collateral_user)
870 test "blocks domain with wildcard for subdomain" do
873 user_from_subdomain =
874 insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})
876 user_with_two_subdomains =
878 ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
881 user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
883 {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
885 assert User.blocks?(user, user_from_subdomain)
886 assert User.blocks?(user, user_with_two_subdomains)
887 assert User.blocks?(user, user_domain)
890 test "unblocks domains" do
892 collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
894 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
895 {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")
897 refute User.blocks?(user, collateral_user)
901 describe "blocks_import" do
902 test "it imports user blocks from list" do
903 [user1, user2, user3] = insert_list(3, :user)
910 {:ok, job} = User.blocks_import(user1, identifiers)
911 result = ObanHelpers.perform(job)
913 assert is_list(result)
914 assert result == [user2, user3]
918 test "get recipients from activity" do
919 actor = insert(:user)
920 user = insert(:user, local: true)
921 user_two = insert(:user, local: false)
922 addressed = insert(:user, local: true)
923 addressed_remote = insert(:user, local: false)
926 CommonAPI.post(actor, %{
927 "status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
930 assert Enum.map([actor, addressed], & &1.ap_id) --
931 Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
933 {:ok, user} = User.follow(user, actor)
934 {:ok, _user_two} = User.follow(user_two, actor)
935 recipients = User.get_recipients_from_activity(activity)
936 assert length(recipients) == 3
937 assert user in recipients
938 assert addressed in recipients
941 describe ".deactivate" do
942 test "can de-activate then re-activate a user" do
944 assert false == user.info.deactivated
945 {:ok, user} = User.deactivate(user)
946 assert true == user.info.deactivated
947 {:ok, user} = User.deactivate(user, false)
948 assert false == user.info.deactivated
951 test "hide a user from followers " do
953 user2 = insert(:user)
955 {:ok, user} = User.follow(user, user2)
956 {:ok, _user} = User.deactivate(user)
958 info = User.get_cached_user_info(user2)
960 assert info.follower_count == 0
961 assert [] = User.get_followers(user2)
964 test "hide a user from friends" do
966 user2 = insert(:user)
968 {:ok, user2} = User.follow(user2, user)
969 assert User.following_count(user2) == 1
971 {:ok, _user} = User.deactivate(user)
973 info = User.get_cached_user_info(user2)
975 assert info.following_count == 0
976 assert User.following_count(user2) == 0
977 assert [] = User.get_friends(user2)
980 test "hide a user's statuses from timelines and notifications" do
982 user2 = insert(:user)
984 {:ok, user2} = User.follow(user2, user)
986 {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}"})
988 activity = Repo.preload(activity, :bookmark)
990 [notification] = Pleroma.Notification.for_user(user2)
991 assert notification.activity.id == activity.id
993 assert [activity] == ActivityPub.fetch_public_activities(%{}) |> Repo.preload(:bookmark)
995 assert [%{activity | thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
996 ActivityPub.fetch_activities([user2.ap_id | user2.following], %{"user" => user2})
998 {:ok, _user} = User.deactivate(user)
1000 assert [] == ActivityPub.fetch_public_activities(%{})
1001 assert [] == Pleroma.Notification.for_user(user2)
1004 ActivityPub.fetch_activities([user2.ap_id | user2.following], %{"user" => user2})
1008 describe "delete" do
1010 {:ok, user} = insert(:user) |> User.set_cache()
1015 clear_config([:instance, :federating])
1017 test ".delete_user_activities deletes all create activities", %{user: user} do
1018 {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
1020 User.delete_user_activities(user)
1022 # TODO: Remove favorites, repeats, delete activities.
1023 refute Activity.get_by_id(activity.id)
1026 test "it deletes deactivated user" do
1027 {:ok, user} = insert(:user, info: %{deactivated: true}) |> User.set_cache()
1029 {:ok, job} = User.delete(user)
1030 {:ok, _user} = ObanHelpers.perform(job)
1032 refute User.get_by_id(user.id)
1035 test "it deletes a user, all follow relationships and all activities", %{user: user} do
1036 follower = insert(:user)
1037 {:ok, follower} = User.follow(follower, user)
1039 object = insert(:note, user: user)
1040 activity = insert(:note_activity, user: user, note: object)
1042 object_two = insert(:note, user: follower)
1043 activity_two = insert(:note_activity, user: follower, note: object_two)
1045 {:ok, like, _} = CommonAPI.favorite(activity_two.id, user)
1046 {:ok, like_two, _} = CommonAPI.favorite(activity.id, follower)
1047 {:ok, repeat, _} = CommonAPI.repeat(activity_two.id, user)
1049 {:ok, job} = User.delete(user)
1050 {:ok, _user} = ObanHelpers.perform(job)
1052 follower = User.get_cached_by_id(follower.id)
1054 refute User.following?(follower, user)
1055 refute User.get_by_id(user.id)
1056 assert {:ok, nil} == Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1060 |> Activity.Queries.by_actor()
1062 |> Enum.map(fn act -> act.data["type"] end)
1064 assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)
1066 refute Activity.get_by_id(activity.id)
1067 refute Activity.get_by_id(like.id)
1068 refute Activity.get_by_id(like_two.id)
1069 refute Activity.get_by_id(repeat.id)
1072 test_with_mock "it sends out User Delete activity",
1074 Pleroma.Web.ActivityPub.Publisher,
1077 Pleroma.Config.put([:instance, :federating], true)
1079 {:ok, follower} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
1080 {:ok, _} = User.follow(follower, user)
1082 {:ok, job} = User.delete(user)
1083 {:ok, _user} = ObanHelpers.perform(job)
1085 assert ObanHelpers.member?(
1087 "op" => "publish_one",
1089 "inbox" => "http://mastodon.example.org/inbox",
1090 "id" => "pleroma:fakeid"
1093 all_enqueued(worker: Pleroma.Workers.PublisherWorker)
1098 test "get_public_key_for_ap_id fetches a user that's not in the db" do
1099 assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
1102 describe "insert or update a user from given data" do
1103 test "with normal data" do
1104 user = insert(:user, %{nickname: "nick@name.de"})
1105 data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}
1107 assert {:ok, %User{}} = User.insert_or_update_user(data)
1110 test "with overly long fields" do
1111 current_max_length = Pleroma.Config.get([:instance, :account_field_value_length], 255)
1112 user = insert(:user, nickname: "nickname@supergood.domain")
1117 nickname: user.nickname,
1120 %{"name" => "myfield", "value" => String.duplicate("h", current_max_length + 1)}
1125 assert {:ok, %User{}} = User.insert_or_update_user(data)
1128 test "with an overly long bio" do
1129 current_max_length = Pleroma.Config.get([:instance, :user_bio_length], 5000)
1130 user = insert(:user, nickname: "nickname@supergood.domain")
1135 nickname: user.nickname,
1136 bio: String.duplicate("h", current_max_length + 1),
1140 assert {:ok, %User{}} = User.insert_or_update_user(data)
1143 test "with an overly long display name" do
1144 current_max_length = Pleroma.Config.get([:instance, :user_name_length], 100)
1145 user = insert(:user, nickname: "nickname@supergood.domain")
1149 name: String.duplicate("h", current_max_length + 1),
1150 nickname: user.nickname,
1154 assert {:ok, %User{}} = User.insert_or_update_user(data)
1158 describe "per-user rich-text filtering" do
1159 test "html_filter_policy returns default policies, when rich-text is enabled" do
1160 user = insert(:user)
1162 assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
1165 test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
1166 user = insert(:user, %{info: %{no_rich_text: true}})
1168 assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
1172 describe "caching" do
1173 test "invalidate_cache works" do
1174 user = insert(:user)
1175 _user_info = User.get_cached_user_info(user)
1177 User.invalidate_cache(user)
1179 {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1180 {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
1181 {:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
1184 test "User.delete() plugs any possible zombie objects" do
1185 user = insert(:user)
1187 {:ok, job} = User.delete(user)
1188 {:ok, _} = ObanHelpers.perform(job)
1190 {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1192 assert cached_user != user
1194 {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")
1196 assert cached_user != user
1200 test "auth_active?/1 works correctly" do
1201 Pleroma.Config.put([:instance, :account_activation_required], true)
1203 local_user = insert(:user, local: true, info: %{confirmation_pending: true})
1204 confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
1205 remote_user = insert(:user, local: false)
1207 refute User.auth_active?(local_user)
1208 assert User.auth_active?(confirmed_user)
1209 assert User.auth_active?(remote_user)
1212 describe "superuser?/1" do
1213 test "returns false for unprivileged users" do
1214 user = insert(:user, local: true)
1216 refute User.superuser?(user)
1219 test "returns false for remote users" do
1220 user = insert(:user, local: false)
1221 remote_admin_user = insert(:user, local: false, info: %{is_admin: true})
1223 refute User.superuser?(user)
1224 refute User.superuser?(remote_admin_user)
1227 test "returns true for local moderators" do
1228 user = insert(:user, local: true, info: %{is_moderator: true})
1230 assert User.superuser?(user)
1233 test "returns true for local admins" do
1234 user = insert(:user, local: true, info: %{is_admin: true})
1236 assert User.superuser?(user)
1240 describe "visible_for?/2" do
1241 test "returns true when the account is itself" do
1242 user = insert(:user, local: true)
1244 assert User.visible_for?(user, user)
1247 test "returns false when the account is unauthenticated and auth is required" do
1248 Pleroma.Config.put([:instance, :account_activation_required], true)
1250 user = insert(:user, local: true, info: %{confirmation_pending: true})
1251 other_user = insert(:user, local: true)
1253 refute User.visible_for?(user, other_user)
1256 test "returns true when the account is unauthenticated and auth is not required" do
1257 user = insert(:user, local: true, info: %{confirmation_pending: true})
1258 other_user = insert(:user, local: true)
1260 assert User.visible_for?(user, other_user)
1263 test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
1264 Pleroma.Config.put([:instance, :account_activation_required], true)
1266 user = insert(:user, local: true, info: %{confirmation_pending: true})
1267 other_user = insert(:user, local: true, info: %{is_admin: true})
1269 assert User.visible_for?(user, other_user)
1273 describe "parse_bio/2" do
1274 test "preserves hosts in user links text" do
1275 remote_user = insert(:user, local: false, nickname: "nick@domain.com")
1276 user = insert(:user)
1277 bio = "A.k.a. @nick@domain.com"
1280 ~s(A.k.a. <span class="h-card"><a data-user="#{remote_user.id}" class="u-url mention" href="#{
1282 }" rel="ugc">@<span>nick@domain.com</span></a></span>)
1284 assert expected_text == User.parse_bio(bio, user)
1287 test "Adds rel=me on linkbacked urls" do
1288 user = insert(:user, ap_id: "https://social.example.org/users/lain")
1290 bio = "http://example.com/rel_me/null"
1291 expected_text = "<a href=\"#{bio}\">#{bio}</a>"
1292 assert expected_text == User.parse_bio(bio, user)
1294 bio = "http://example.com/rel_me/link"
1295 expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
1296 assert expected_text == User.parse_bio(bio, user)
1298 bio = "http://example.com/rel_me/anchor"
1299 expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
1300 assert expected_text == User.parse_bio(bio, user)
1304 test "follower count is updated when a follower is blocked" do
1305 user = insert(:user)
1306 follower = insert(:user)
1307 follower2 = insert(:user)
1308 follower3 = insert(:user)
1310 {:ok, follower} = User.follow(follower, user)
1311 {:ok, _follower2} = User.follow(follower2, user)
1312 {:ok, _follower3} = User.follow(follower3, user)
1314 {:ok, user} = User.block(user, follower)
1316 assert User.user_info(user).follower_count == 2
1319 describe "list_inactive_users_query/1" do
1320 defp days_ago(days) do
1322 NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
1323 -days * 60 * 60 * 24,
1328 test "Users are inactive by default" do
1332 Enum.map(1..total, fn _ ->
1333 insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
1336 inactive_users_ids =
1337 Pleroma.User.list_inactive_users_query()
1338 |> Pleroma.Repo.all()
1339 |> Enum.map(& &1.id)
1341 Enum.each(users, fn user ->
1342 assert user.id in inactive_users_ids
1346 test "Only includes users who has no recent activity" do
1350 Enum.map(1..total, fn _ ->
1351 insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
1354 {inactive, active} = Enum.split(users, trunc(total / 2))
1356 Enum.map(active, fn user ->
1357 to = Enum.random(users -- [user])
1360 CommonAPI.post(user, %{
1361 "status" => "hey @#{to.nickname}"
1365 inactive_users_ids =
1366 Pleroma.User.list_inactive_users_query()
1367 |> Pleroma.Repo.all()
1368 |> Enum.map(& &1.id)
1370 Enum.each(active, fn user ->
1371 refute user.id in inactive_users_ids
1374 Enum.each(inactive, fn user ->
1375 assert user.id in inactive_users_ids
1379 test "Only includes users with no read notifications" do
1383 Enum.map(1..total, fn _ ->
1384 insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
1387 [sender | recipients] = users
1388 {inactive, active} = Enum.split(recipients, trunc(total / 2))
1390 Enum.each(recipients, fn to ->
1392 CommonAPI.post(sender, %{
1393 "status" => "hey @#{to.nickname}"
1397 CommonAPI.post(sender, %{
1398 "status" => "hey again @#{to.nickname}"
1402 Enum.each(active, fn user ->
1403 [n1, _n2] = Pleroma.Notification.for_user(user)
1404 {:ok, _} = Pleroma.Notification.read_one(user, n1.id)
1407 inactive_users_ids =
1408 Pleroma.User.list_inactive_users_query()
1409 |> Pleroma.Repo.all()
1410 |> Enum.map(& &1.id)
1412 Enum.each(active, fn user ->
1413 refute user.id in inactive_users_ids
1416 Enum.each(inactive, fn user ->
1417 assert user.id in inactive_users_ids
1422 describe "toggle_confirmation/1" do
1423 test "if user is confirmed" do
1424 user = insert(:user, info: %{confirmation_pending: false})
1425 {:ok, user} = User.toggle_confirmation(user)
1427 assert user.info.confirmation_pending
1428 assert user.info.confirmation_token
1431 test "if user is unconfirmed" do
1432 user = insert(:user, info: %{confirmation_pending: true, confirmation_token: "some token"})
1433 {:ok, user} = User.toggle_confirmation(user)
1435 refute user.info.confirmation_pending
1436 refute user.info.confirmation_token
1440 describe "ensure_keys_present" do
1441 test "it creates keys for a user and stores them in info" do
1442 user = insert(:user)
1443 refute is_binary(user.keys)
1444 {:ok, user} = User.ensure_keys_present(user)
1445 assert is_binary(user.keys)
1448 test "it doesn't create keys if there already are some" do
1449 user = insert(:user, keys: "xxx")
1450 {:ok, user} = User.ensure_keys_present(user)
1451 assert user.keys == "xxx"
1455 describe "get_ap_ids_by_nicknames" do
1456 test "it returns a list of AP ids for a given set of nicknames" do
1457 user = insert(:user)
1458 user_two = insert(:user)
1460 ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
1461 assert length(ap_ids) == 2
1462 assert user.ap_id in ap_ids
1463 assert user_two.ap_id in ap_ids
1467 describe "sync followers count" do
1469 user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
1470 user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
1471 insert(:user, local: true)
1472 insert(:user, local: false, info: %{deactivated: true})
1473 {:ok, user1: user1, user2: user2}
1476 test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
1477 [fdb_user1] = User.external_users(limit: 1)
1479 assert fdb_user1.ap_id
1480 assert fdb_user1.ap_id == user1.ap_id
1481 assert fdb_user1.id == user1.id
1483 [fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)
1485 assert fdb_user2.ap_id
1486 assert fdb_user2.ap_id == user2.ap_id
1487 assert fdb_user2.id == user2.id
1489 assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
1493 describe "set_info_cache/2" do
1495 user = insert(:user)
1499 test "update from args", %{user: user} do
1500 User.set_info_cache(user, %{following_count: 15, follower_count: 18})
1502 %{follower_count: followers, following_count: following} = User.get_cached_user_info(user)
1503 assert followers == 18
1504 assert following == 15
1507 test "without args", %{user: user} do
1508 User.set_info_cache(user, %{})
1510 %{follower_count: followers, following_count: following} = User.get_cached_user_info(user)
1511 assert followers == 0
1512 assert following == 0
1516 describe "user_info/2" do
1518 user = insert(:user)
1522 test "update from args", %{user: user} do
1523 %{follower_count: followers, following_count: following} =
1524 User.user_info(user, %{following_count: 15, follower_count: 18})
1526 assert followers == 18
1527 assert following == 15
1530 test "without args", %{user: user} do
1531 %{follower_count: followers, following_count: following} = User.user_info(user)
1533 assert followers == 0
1534 assert following == 0
1538 describe "is_internal_user?/1" do
1539 test "non-internal user returns false" do
1540 user = insert(:user)
1541 refute User.is_internal_user?(user)
1544 test "user with no nickname returns true" do
1545 user = insert(:user, %{nickname: nil})
1546 assert User.is_internal_user?(user)
1549 test "user with internal-prefixed nickname returns true" do
1550 user = insert(:user, %{nickname: "internal.test"})
1551 assert User.is_internal_user?(user)
1555 describe "update_and_set_cache/1" do
1556 test "returns error when user is stale instead Ecto.StaleEntryError" do
1557 user = insert(:user)
1559 changeset = Ecto.Changeset.change(user, bio: "test")
1563 assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
1564 User.update_and_set_cache(changeset)
1567 test "performs update cache if user updated" do
1568 user = insert(:user)
1569 assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1571 changeset = Ecto.Changeset.change(user, bio: "test-bio")
1573 assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
1574 assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1575 assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
1579 describe "following/followers synchronization" do
1580 clear_config([:instance, :external_user_synchronization])
1582 test "updates the counters normally on following/getting a follow when disabled" do
1583 Pleroma.Config.put([:instance, :external_user_synchronization], false)
1584 user = insert(:user)
1589 follower_address: "http://localhost:4001/users/masto_closed/followers",
1590 following_address: "http://localhost:4001/users/masto_closed/following",
1591 info: %{ap_enabled: true}
1594 assert User.user_info(other_user).following_count == 0
1595 assert User.user_info(other_user).follower_count == 0
1597 {:ok, user} = Pleroma.User.follow(user, other_user)
1598 other_user = Pleroma.User.get_by_id(other_user.id)
1600 assert User.user_info(user).following_count == 1
1601 assert User.user_info(other_user).follower_count == 1
1604 test "syncronizes the counters with the remote instance for the followed when enabled" do
1605 Pleroma.Config.put([:instance, :external_user_synchronization], false)
1607 user = insert(:user)
1612 follower_address: "http://localhost:4001/users/masto_closed/followers",
1613 following_address: "http://localhost:4001/users/masto_closed/following",
1614 info: %{ap_enabled: true}
1617 assert User.user_info(other_user).following_count == 0
1618 assert User.user_info(other_user).follower_count == 0
1620 Pleroma.Config.put([:instance, :external_user_synchronization], true)
1621 {:ok, _user} = User.follow(user, other_user)
1622 other_user = User.get_by_id(other_user.id)
1624 assert User.user_info(other_user).follower_count == 437
1627 test "syncronizes the counters with the remote instance for the follower when enabled" do
1628 Pleroma.Config.put([:instance, :external_user_synchronization], false)
1630 user = insert(:user)
1635 follower_address: "http://localhost:4001/users/masto_closed/followers",
1636 following_address: "http://localhost:4001/users/masto_closed/following",
1637 info: %{ap_enabled: true}
1640 assert User.user_info(other_user).following_count == 0
1641 assert User.user_info(other_user).follower_count == 0
1643 Pleroma.Config.put([:instance, :external_user_synchronization], true)
1644 {:ok, other_user} = User.follow(other_user, user)
1646 assert User.user_info(other_user).following_count == 152
1650 describe "change_email/2" do
1652 [user: insert(:user)]
1655 test "blank email returns error", %{user: user} do
1656 assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
1657 assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
1660 test "non unique email returns error", %{user: user} do
1661 %{email: email} = insert(:user)
1663 assert {:error, %{errors: [email: {"has already been taken", _}]}} =
1664 User.change_email(user, email)
1667 test "invalid email returns error", %{user: user} do
1668 assert {:error, %{errors: [email: {"has invalid format", _}]}} =
1669 User.change_email(user, "cofe")
1672 test "changes email", %{user: user} do
1673 assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
1677 describe "set_password_reset_pending/2" do
1679 [user: insert(:user)]
1682 test "sets password_reset_pending to true", %{user: user} do
1683 %{password_reset_pending: password_reset_pending} = user.info
1685 refute password_reset_pending
1687 {:ok, %{info: %{password_reset_pending: password_reset_pending}}} =
1688 User.force_password_reset(user)
1690 assert password_reset_pending
1694 test "change_info/2" do
1695 user = insert(:user)
1696 assert user.info.hide_follows == false
1698 changeset = User.change_info(user, &User.Info.profile_update(&1, %{hide_follows: true}))
1699 assert changeset.changes.info.changes.hide_follows == true
1702 test "update_info/2" do
1703 user = insert(:user)
1704 assert user.info.hide_follows == false
1706 assert {:ok, _} = User.update_info(user, &User.Info.profile_update(&1, %{hide_follows: true}))
1708 assert %{info: %{hide_follows: true}} = Repo.get(User, user.id)
1709 assert {:ok, %{info: %{hide_follows: true}}} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1712 describe "get_cached_by_nickname_or_id" do
1714 limit_to_local_content = Pleroma.Config.get([:instance, :limit_to_local_content])
1715 local_user = insert(:user)
1716 remote_user = insert(:user, nickname: "nickname@example.com", local: false)
1719 Pleroma.Config.put([:instance, :limit_to_local_content], limit_to_local_content)
1722 [local_user: local_user, remote_user: remote_user]
1725 test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
1726 remote_user: remote_user
1728 Pleroma.Config.put([:instance, :limit_to_local_content], false)
1729 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
1731 Pleroma.Config.put([:instance, :limit_to_local_content], true)
1732 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
1734 Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1735 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
1738 test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
1739 %{remote_user: remote_user} do
1740 Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1741 assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
1744 test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
1745 %{remote_user: remote_user, local_user: local_user} do
1746 Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1747 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
1750 test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
1751 %{remote_user: remote_user} do
1752 Pleroma.Config.put([:instance, :limit_to_local_content], true)
1753 assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
1756 test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
1757 %{local_user: local_user} do
1758 Pleroma.Config.put([:instance, :limit_to_local_content], false)
1759 assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
1761 Pleroma.Config.put([:instance, :limit_to_local_content], true)
1762 assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
1764 Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
1765 assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)