1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 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
18 import Pleroma.Factory
19 import ExUnit.CaptureLog
20 import Swoosh.TestAssertions
23 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
27 setup do: clear_config([:instance, :account_activation_required])
29 describe "service actors" do
30 test "returns updated invisible actor" do
31 uri = "#{Pleroma.Web.Endpoint.url()}/relay"
32 followers_uri = "#{uri}/followers"
41 follower_address: followers_uri
45 actor = User.get_or_create_service_actor_by_ap_id(uri, "relay")
46 assert actor.invisible
49 test "returns relay user" do
50 uri = "#{Pleroma.Web.Endpoint.url()}/relay"
51 followers_uri = "#{uri}/followers"
58 follower_address: ^followers_uri
59 } = User.get_or_create_service_actor_by_ap_id(uri, "relay")
61 assert capture_log(fn ->
62 refute User.get_or_create_service_actor_by_ap_id("/relay", "relay")
63 end) =~ "Cannot create service actor:"
66 test "returns invisible actor" do
67 uri = "#{Pleroma.Web.Endpoint.url()}/internal/fetch-test"
68 followers_uri = "#{uri}/followers"
69 user = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
72 nickname: "internal.fetch-test",
76 follower_address: ^followers_uri
79 user2 = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
80 assert user.id == user2.id
84 describe "AP ID user relationships" do
86 {:ok, user: insert(:user)}
89 test "outgoing_relationships_ap_ids/1", %{user: user} do
90 rel_types = [:block, :mute, :notification_mute, :reblog_mute, :inverse_subscription]
98 insert_list(2, :user_relationship, %{source: user, relationship_type: rel_type})
100 ap_ids = Enum.map(rel_records, fn rr -> Repo.preload(rr, :target).target.ap_id end)
101 {rel_type, Enum.sort(ap_ids)}
105 assert ap_ids_by_rel[:block] == Enum.sort(User.blocked_users_ap_ids(user))
106 assert ap_ids_by_rel[:block] == Enum.sort(Enum.map(User.blocked_users(user), & &1.ap_id))
108 assert ap_ids_by_rel[:mute] == Enum.sort(User.muted_users_ap_ids(user))
109 assert ap_ids_by_rel[:mute] == Enum.sort(Enum.map(User.muted_users(user), & &1.ap_id))
111 assert ap_ids_by_rel[:notification_mute] ==
112 Enum.sort(User.notification_muted_users_ap_ids(user))
114 assert ap_ids_by_rel[:notification_mute] ==
115 Enum.sort(Enum.map(User.notification_muted_users(user), & &1.ap_id))
117 assert ap_ids_by_rel[:reblog_mute] == Enum.sort(User.reblog_muted_users_ap_ids(user))
119 assert ap_ids_by_rel[:reblog_mute] ==
120 Enum.sort(Enum.map(User.reblog_muted_users(user), & &1.ap_id))
122 assert ap_ids_by_rel[:inverse_subscription] == Enum.sort(User.subscriber_users_ap_ids(user))
124 assert ap_ids_by_rel[:inverse_subscription] ==
125 Enum.sort(Enum.map(User.subscriber_users(user), & &1.ap_id))
127 outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)
129 assert ap_ids_by_rel ==
130 Enum.into(outgoing_relationships_ap_ids, %{}, fn {k, v} -> {k, Enum.sort(v)} end)
134 describe "when tags are nil" do
135 test "tagging a user" do
136 user = insert(:user, %{tags: nil})
137 user = User.tag(user, ["cool", "dude"])
139 assert "cool" in user.tags
140 assert "dude" in user.tags
143 test "untagging a user" do
144 user = insert(:user, %{tags: nil})
145 user = User.untag(user, ["cool", "dude"])
147 assert user.tags == []
151 test "ap_id returns the activity pub id for the user" do
152 user = UserBuilder.build()
154 expected_ap_id = "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}"
156 assert expected_ap_id == User.ap_id(user)
159 test "ap_followers returns the followers collection for the user" do
160 user = UserBuilder.build()
162 expected_followers_collection = "#{User.ap_id(user)}/followers"
164 assert expected_followers_collection == User.ap_followers(user)
167 test "ap_following returns the following collection for the user" do
168 user = UserBuilder.build()
170 expected_followers_collection = "#{User.ap_id(user)}/following"
172 assert expected_followers_collection == User.ap_following(user)
175 test "returns all pending follow requests" do
176 unlocked = insert(:user)
177 locked = insert(:user, is_locked: true)
178 follower = insert(:user)
180 CommonAPI.follow(follower, unlocked)
181 CommonAPI.follow(follower, locked)
183 assert [] = User.get_follow_requests(unlocked)
184 assert [activity] = User.get_follow_requests(locked)
189 test "doesn't return already accepted or duplicate follow requests" do
190 locked = insert(:user, is_locked: true)
191 pending_follower = insert(:user)
192 accepted_follower = insert(:user)
194 CommonAPI.follow(pending_follower, locked)
195 CommonAPI.follow(pending_follower, locked)
196 CommonAPI.follow(accepted_follower, locked)
198 Pleroma.FollowingRelationship.update(accepted_follower, locked, :follow_accept)
200 assert [^pending_follower] = User.get_follow_requests(locked)
203 test "doesn't return follow requests for deactivated accounts" do
204 locked = insert(:user, is_locked: true)
205 pending_follower = insert(:user, %{is_active: false})
207 CommonAPI.follow(pending_follower, locked)
209 refute pending_follower.is_active
210 assert [] = User.get_follow_requests(locked)
213 test "clears follow requests when requester is blocked" do
214 followed = insert(:user, is_locked: true)
215 follower = insert(:user)
217 CommonAPI.follow(follower, followed)
218 assert [_activity] = User.get_follow_requests(followed)
220 {:ok, _user_relationship} = User.block(followed, follower)
221 assert [] = User.get_follow_requests(followed)
224 test "follow_all follows mutliple users" do
226 followed_zero = insert(:user)
227 followed_one = insert(:user)
228 followed_two = insert(:user)
229 blocked = insert(:user)
230 not_followed = insert(:user)
231 reverse_blocked = insert(:user)
233 {:ok, _user_relationship} = User.block(user, blocked)
234 {:ok, _user_relationship} = User.block(reverse_blocked, user)
236 {:ok, user, followed_zero} = User.follow(user, followed_zero)
238 {:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])
240 assert User.following?(user, followed_one)
241 assert User.following?(user, followed_two)
242 assert User.following?(user, followed_zero)
243 refute User.following?(user, not_followed)
244 refute User.following?(user, blocked)
245 refute User.following?(user, reverse_blocked)
248 test "follow_all follows mutliple users without duplicating" do
250 followed_zero = insert(:user)
251 followed_one = insert(:user)
252 followed_two = insert(:user)
254 {:ok, user} = User.follow_all(user, [followed_zero, followed_one])
255 assert length(User.following(user)) == 3
257 {:ok, user} = User.follow_all(user, [followed_one, followed_two])
258 assert length(User.following(user)) == 4
261 test "follow takes a user and another user" do
263 followed = insert(:user)
265 {:ok, user, followed} = User.follow(user, followed)
267 user = User.get_cached_by_id(user.id)
268 followed = User.get_cached_by_ap_id(followed.ap_id)
270 assert followed.follower_count == 1
271 assert user.following_count == 1
273 assert User.ap_followers(followed) in User.following(user)
276 test "can't follow a deactivated users" do
278 followed = insert(:user, %{is_active: false})
280 {:error, _} = User.follow(user, followed)
283 test "can't follow a user who blocked us" do
284 blocker = insert(:user)
285 blockee = insert(:user)
287 {:ok, _user_relationship} = User.block(blocker, blockee)
289 {:error, _} = User.follow(blockee, blocker)
292 test "can't subscribe to a user who blocked us" do
293 blocker = insert(:user)
294 blocked = insert(:user)
296 {:ok, _user_relationship} = User.block(blocker, blocked)
298 {:error, _} = User.subscribe(blocked, blocker)
301 test "local users do not automatically follow local locked accounts" do
302 follower = insert(:user, is_locked: true)
303 followed = insert(:user, is_locked: true)
305 {:ok, follower, followed} = User.maybe_direct_follow(follower, followed)
307 refute User.following?(follower, followed)
310 describe "unfollow/2" do
311 setup do: clear_config([:instance, :external_user_synchronization])
313 test "unfollow with syncronizes external user" do
314 clear_config([:instance, :external_user_synchronization], true)
319 follower_address: "http://localhost:4001/users/fuser1/followers",
320 following_address: "http://localhost:4001/users/fuser1/following",
321 ap_id: "http://localhost:4001/users/fuser1"
328 ap_id: "http://localhost:4001/users/fuser2",
329 follower_address: "http://localhost:4001/users/fuser2/followers",
330 following_address: "http://localhost:4001/users/fuser2/following"
333 {:ok, user, followed} = User.follow(user, followed, :follow_accept)
335 {:ok, user, _activity} = User.unfollow(user, followed)
337 user = User.get_cached_by_id(user.id)
339 assert User.following(user) == []
342 test "unfollow takes a user and another user" do
343 followed = insert(:user)
346 {:ok, user, followed} = User.follow(user, followed, :follow_accept)
348 assert User.following(user) == [user.follower_address, followed.follower_address]
350 {:ok, user, _activity} = User.unfollow(user, followed)
352 assert User.following(user) == [user.follower_address]
355 test "unfollow doesn't unfollow yourself" do
358 {:error, _} = User.unfollow(user, user)
360 assert User.following(user) == [user.follower_address]
364 test "test if a user is following another user" do
365 followed = insert(:user)
367 User.follow(user, followed, :follow_accept)
369 assert User.following?(user, followed)
370 refute User.following?(followed, user)
373 test "fetches correct profile for nickname beginning with number" do
374 # Use old-style integer ID to try to reproduce the problem
375 user = insert(:user, %{id: 1080})
376 user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
377 assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
380 describe "user registration" do
386 password_confirmation: "test",
387 email: "email@example.com"
390 setup do: clear_config([:instance, :autofollowed_nicknames])
391 setup do: clear_config([:instance, :autofollowing_nicknames])
392 setup do: clear_config([:welcome])
393 setup do: clear_config([:instance, :account_activation_required])
395 test "it autofollows accounts that are set for it" do
397 remote_user = insert(:user, %{local: false})
399 clear_config([:instance, :autofollowed_nicknames], [
404 cng = User.register_changeset(%User{}, @full_user_data)
406 {:ok, registered_user} = User.register(cng)
408 assert User.following?(registered_user, user)
409 refute User.following?(registered_user, remote_user)
412 test "it adds automatic followers for new registered accounts" do
413 user1 = insert(:user)
414 user2 = insert(:user)
416 clear_config([:instance, :autofollowing_nicknames], [
421 cng = User.register_changeset(%User{}, @full_user_data)
423 {:ok, registered_user} = User.register(cng)
425 assert User.following?(user1, registered_user)
426 assert User.following?(user2, registered_user)
429 test "it sends a welcome message if it is set" do
430 welcome_user = insert(:user)
431 clear_config([:welcome, :direct_message, :enabled], true)
432 clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
433 clear_config([:welcome, :direct_message, :message], "Hello, this is a direct message")
435 cng = User.register_changeset(%User{}, @full_user_data)
436 {:ok, registered_user} = User.register(cng)
437 ObanHelpers.perform_all()
439 activity = Repo.one(Pleroma.Activity)
440 assert registered_user.ap_id in activity.recipients
441 assert Object.normalize(activity, fetch: false).data["content"] =~ "direct message"
442 assert activity.actor == welcome_user.ap_id
445 test "it sends a welcome chat message if it is set" do
446 welcome_user = insert(:user)
447 clear_config([:welcome, :chat_message, :enabled], true)
448 clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
449 clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")
451 cng = User.register_changeset(%User{}, @full_user_data)
452 {:ok, registered_user} = User.register(cng)
453 ObanHelpers.perform_all()
455 activity = Repo.one(Pleroma.Activity)
456 assert registered_user.ap_id in activity.recipients
457 assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
458 assert activity.actor == welcome_user.ap_id
462 clear_config(:mrf_simple,
465 federated_timeline_removal: [],
478 Pleroma.Web.ActivityPub.MRF.SimplePolicy
482 test "it sends a welcome chat message when Simple policy applied to local instance" do
483 clear_config([:mrf_simple, :media_nsfw], ["localhost"])
485 welcome_user = insert(:user)
486 clear_config([:welcome, :chat_message, :enabled], true)
487 clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
488 clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")
490 cng = User.register_changeset(%User{}, @full_user_data)
491 {:ok, registered_user} = User.register(cng)
492 ObanHelpers.perform_all()
494 activity = Repo.one(Pleroma.Activity)
495 assert registered_user.ap_id in activity.recipients
496 assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
497 assert activity.actor == welcome_user.ap_id
500 test "it sends a welcome email message if it is set" do
501 welcome_user = insert(:user)
502 clear_config([:welcome, :email, :enabled], true)
503 clear_config([:welcome, :email, :sender], welcome_user.email)
506 [:welcome, :email, :subject],
507 "Hello, welcome to cool site: <%= instance_name %>"
510 instance_name = Pleroma.Config.get([:instance, :name])
512 cng = User.register_changeset(%User{}, @full_user_data)
513 {:ok, registered_user} = User.register(cng)
514 ObanHelpers.perform_all()
517 from: {instance_name, welcome_user.email},
518 to: {registered_user.name, registered_user.email},
519 subject: "Hello, welcome to cool site: #{instance_name}",
520 html_body: "Welcome to #{instance_name}"
524 test "it sends a confirm email" do
525 clear_config([:instance, :account_activation_required], true)
527 cng = User.register_changeset(%User{}, @full_user_data)
528 {:ok, registered_user} = User.register(cng)
529 ObanHelpers.perform_all()
531 Pleroma.Emails.UserEmail.account_confirmation_email(registered_user)
532 # temporary hackney fix until hackney max_connections bug is fixed
533 # https://git.pleroma.social/pleroma/pleroma/-/issues/2101
534 |> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
535 |> assert_email_sent()
538 test "sends a pending approval email" do
539 clear_config([:instance, :account_approval_required], true)
542 User.register_changeset(%User{}, @full_user_data)
545 ObanHelpers.perform_all()
548 from: Pleroma.Config.Helpers.sender(),
549 to: {user.name, user.email},
550 subject: "Your account is awaiting approval"
554 test "it sends a registration confirmed email if no others will be sent" do
555 clear_config([:welcome, :email, :enabled], false)
556 clear_config([:instance, :account_activation_required], false)
557 clear_config([:instance, :account_approval_required], false)
560 User.register_changeset(%User{}, @full_user_data)
563 ObanHelpers.perform_all()
565 instance_name = Pleroma.Config.get([:instance, :name])
566 sender = Pleroma.Config.get([:instance, :notify_email])
569 from: {instance_name, sender},
570 to: {user.name, user.email},
571 subject: "Account registered on #{instance_name}"
575 test "it fails gracefully with invalid email config" do
576 cng = User.register_changeset(%User{}, @full_user_data)
578 # Disable the mailer but enable all the things that want to send emails
579 clear_config([Pleroma.Emails.Mailer, :enabled], false)
580 clear_config([:instance, :account_activation_required], true)
581 clear_config([:instance, :account_approval_required], true)
582 clear_config([:welcome, :email, :enabled], true)
583 clear_config([:welcome, :email, :sender], "lain@lain.com")
585 # The user is still created
586 assert {:ok, %User{nickname: "nick"}} = User.register(cng)
589 ObanHelpers.perform_all()
593 test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
594 clear_config([:instance, :account_activation_required], true)
598 |> Enum.each(fn key ->
599 params = Map.delete(@full_user_data, key)
600 changeset = User.register_changeset(%User{}, params)
602 assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
606 test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
607 clear_config([:instance, :account_activation_required], false)
611 |> Enum.each(fn key ->
612 params = Map.delete(@full_user_data, key)
613 changeset = User.register_changeset(%User{}, params)
615 assert if key in [:bio, :email], do: changeset.valid?, else: not changeset.valid?
619 test "it restricts certain nicknames" do
620 [restricted_name | _] = Pleroma.Config.get([User, :restricted_nicknames])
622 assert is_bitstring(restricted_name)
626 |> Map.put(:nickname, restricted_name)
628 changeset = User.register_changeset(%User{}, params)
630 refute changeset.valid?
633 test "it blocks blacklisted email domains" do
634 clear_config([User, :email_blacklist], ["trolling.world"])
637 params = Map.put(@full_user_data, :email, "troll@trolling.world")
638 changeset = User.register_changeset(%User{}, params)
639 refute changeset.valid?
641 # Block with subdomain match
642 params = Map.put(@full_user_data, :email, "troll@gnomes.trolling.world")
643 changeset = User.register_changeset(%User{}, params)
644 refute changeset.valid?
646 # Pass with different domains that are similar
647 params = Map.put(@full_user_data, :email, "troll@gnomestrolling.world")
648 changeset = User.register_changeset(%User{}, params)
649 assert changeset.valid?
651 params = Map.put(@full_user_data, :email, "troll@trolling.world.us")
652 changeset = User.register_changeset(%User{}, params)
653 assert changeset.valid?
656 test "it sets the password_hash and ap_id" do
657 changeset = User.register_changeset(%User{}, @full_user_data)
659 assert changeset.valid?
661 assert is_binary(changeset.changes[:password_hash])
662 assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
664 assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
667 test "it sets the 'accepts_chat_messages' set to true" do
668 changeset = User.register_changeset(%User{}, @full_user_data)
669 assert changeset.valid?
671 {:ok, user} = Repo.insert(changeset)
673 assert user.accepts_chat_messages
676 test "it creates a confirmed user" do
677 changeset = User.register_changeset(%User{}, @full_user_data)
678 assert changeset.valid?
680 {:ok, user} = Repo.insert(changeset)
682 assert user.is_confirmed
686 describe "user registration, with :account_activation_required" do
692 password_confirmation: "test",
693 email: "email@example.com"
695 setup do: clear_config([:instance, :account_activation_required], true)
697 test "it creates unconfirmed user" do
698 changeset = User.register_changeset(%User{}, @full_user_data)
699 assert changeset.valid?
701 {:ok, user} = Repo.insert(changeset)
703 refute user.is_confirmed
704 assert user.confirmation_token
707 test "it creates confirmed user if :confirmed option is given" do
708 changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
709 assert changeset.valid?
711 {:ok, user} = Repo.insert(changeset)
713 assert user.is_confirmed
714 refute user.confirmation_token
718 describe "user registration, with :account_approval_required" do
724 password_confirmation: "test",
725 email: "email@example.com",
726 registration_reason: "I'm a cool guy :)"
728 setup do: clear_config([:instance, :account_approval_required], true)
730 test "it creates unapproved user" do
731 changeset = User.register_changeset(%User{}, @full_user_data)
732 assert changeset.valid?
734 {:ok, user} = Repo.insert(changeset)
736 refute user.is_approved
737 assert user.registration_reason == "I'm a cool guy :)"
740 test "it restricts length of registration reason" do
741 reason_limit = Pleroma.Config.get([:instance, :registration_reason_length])
743 assert is_integer(reason_limit)
748 :registration_reason,
749 "Quia et nesciunt dolores numquam ipsam nisi sapiente soluta. Ullam repudiandae nisi quam porro officiis officiis ad. Consequatur animi velit ex quia. Odit voluptatem perferendis quia ut nisi. Dignissimos sit soluta atque aliquid dolorem ut dolorum ut. Labore voluptates iste iusto amet voluptatum earum. Ad fugit illum nam eos ut nemo. Pariatur ea fuga non aspernatur. Dignissimos debitis officia corporis est nisi ab et. Atque itaque alias eius voluptas minus. Accusamus numquam tempore occaecati in."
752 changeset = User.register_changeset(%User{}, params)
754 refute changeset.valid?
758 describe "get_or_fetch/1" do
759 test "gets an existing user by nickname" do
761 {:ok, fetched_user} = User.get_or_fetch(user.nickname)
763 assert user == fetched_user
766 test "gets an existing user by ap_id" do
767 ap_id = "http://mastodon.example.org/users/admin"
773 nickname: "admin@mastodon.example.org",
777 {:ok, fetched_user} = User.get_or_fetch(ap_id)
778 freshed_user = refresh_record(user)
779 assert freshed_user == fetched_user
783 describe "fetching a user from nickname or trying to build one" do
784 test "gets an existing user" do
786 {:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)
788 assert user == fetched_user
791 test "gets an existing user, case insensitive" do
792 user = insert(:user, nickname: "nick")
793 {:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")
795 assert user == fetched_user
798 test "gets an existing user by fully qualified nickname" do
801 {:ok, fetched_user} =
802 User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
804 assert user == fetched_user
807 test "gets an existing user by fully qualified nickname, case insensitive" do
808 user = insert(:user, nickname: "nick")
809 casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
811 {:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)
813 assert user == fetched_user
816 @tag capture_log: true
817 test "returns nil if no user could be fetched" do
818 {:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
819 assert fetched_user == "not found nonexistant@social.heldscal.la"
822 test "returns nil for nonexistant local user" do
823 {:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
824 assert fetched_user == "not found nonexistant"
827 test "updates an existing user, if stale" do
828 a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
834 nickname: "admin@mastodon.example.org",
835 ap_id: "http://mastodon.example.org/users/admin",
836 last_refreshed_at: a_week_ago
839 assert orig_user.last_refreshed_at == a_week_ago
841 {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
845 refute user.last_refreshed_at == orig_user.last_refreshed_at
848 test "if nicknames clash, the old user gets a prefix with the old id to the nickname" do
849 a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
855 nickname: "admin@mastodon.example.org",
856 ap_id: "http://mastodon.example.org/users/harinezumigari",
857 last_refreshed_at: a_week_ago
860 assert orig_user.last_refreshed_at == a_week_ago
862 {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
866 refute user.id == orig_user.id
868 orig_user = User.get_by_id(orig_user.id)
870 assert orig_user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
873 @tag capture_log: true
874 test "it returns the old user if stale, but unfetchable" do
875 a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
881 nickname: "admin@mastodon.example.org",
882 ap_id: "http://mastodon.example.org/users/raymoo",
883 last_refreshed_at: a_week_ago
886 assert orig_user.last_refreshed_at == a_week_ago
888 {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/raymoo")
890 assert user.last_refreshed_at == orig_user.last_refreshed_at
894 test "returns an ap_id for a user" do
897 assert User.ap_id(user) ==
898 Pleroma.Web.Router.Helpers.user_feed_url(
899 Pleroma.Web.Endpoint,
905 test "returns an ap_followers link for a user" do
908 assert User.ap_followers(user) ==
909 Pleroma.Web.Router.Helpers.user_feed_url(
910 Pleroma.Web.Endpoint,
916 describe "remote user changeset" do
922 avatar: %{some: "avatar"}
924 setup do: clear_config([:instance, :user_bio_length])
925 setup do: clear_config([:instance, :user_name_length])
927 test "it confirms validity" do
928 cs = User.remote_user_changeset(@valid_remote)
932 test "it sets the follower_adress" do
933 cs = User.remote_user_changeset(@valid_remote)
934 # remote users get a fake local follower address
935 assert cs.changes.follower_address ==
936 User.ap_followers(%User{nickname: @valid_remote[:nickname]})
939 test "it enforces the fqn format for nicknames" do
940 cs = User.remote_user_changeset(%{@valid_remote | nickname: "bla"})
941 assert Ecto.Changeset.get_field(cs, :local) == false
942 assert cs.changes.avatar
946 test "it has required fields" do
948 |> Enum.each(fn field ->
949 cs = User.remote_user_changeset(Map.delete(@valid_remote, field))
954 test "it is invalid given a local user" do
956 cs = User.remote_user_changeset(user, %{name: "tom from myspace"})
962 describe "followers and friends" do
963 test "gets all followers for a given user" do
965 follower_one = insert(:user)
966 follower_two = insert(:user)
967 not_follower = insert(:user)
969 {:ok, follower_one, user} = User.follow(follower_one, user)
970 {:ok, follower_two, user} = User.follow(follower_two, user)
972 res = User.get_followers(user)
974 assert Enum.member?(res, follower_one)
975 assert Enum.member?(res, follower_two)
976 refute Enum.member?(res, not_follower)
979 test "gets all friends (followed users) for a given user" do
981 followed_one = insert(:user)
982 followed_two = insert(:user)
983 not_followed = insert(:user)
985 {:ok, user, followed_one} = User.follow(user, followed_one)
986 {:ok, user, followed_two} = User.follow(user, followed_two)
988 res = User.get_friends(user)
990 followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
991 followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
992 assert Enum.member?(res, followed_one)
993 assert Enum.member?(res, followed_two)
994 refute Enum.member?(res, not_followed)
998 describe "updating note and follower count" do
999 test "it sets the note_count property" do
1000 note = insert(:note)
1002 user = User.get_cached_by_ap_id(note.data["actor"])
1004 assert user.note_count == 0
1006 {:ok, user} = User.update_note_count(user)
1008 assert user.note_count == 1
1011 test "it increases the note_count property" do
1012 note = insert(:note)
1013 user = User.get_cached_by_ap_id(note.data["actor"])
1015 assert user.note_count == 0
1017 {:ok, user} = User.increase_note_count(user)
1019 assert user.note_count == 1
1021 {:ok, user} = User.increase_note_count(user)
1023 assert user.note_count == 2
1026 test "it decreases the note_count property" do
1027 note = insert(:note)
1028 user = User.get_cached_by_ap_id(note.data["actor"])
1030 assert user.note_count == 0
1032 {:ok, user} = User.increase_note_count(user)
1034 assert user.note_count == 1
1036 {:ok, user} = User.decrease_note_count(user)
1038 assert user.note_count == 0
1040 {:ok, user} = User.decrease_note_count(user)
1042 assert user.note_count == 0
1045 test "it sets the follower_count property" do
1046 user = insert(:user)
1047 follower = insert(:user)
1049 User.follow(follower, user)
1051 assert user.follower_count == 0
1053 {:ok, user} = User.update_follower_count(user)
1055 assert user.follower_count == 1
1060 test "it mutes people" do
1061 user = insert(:user)
1062 muted_user = insert(:user)
1064 refute User.mutes?(user, muted_user)
1065 refute User.muted_notifications?(user, muted_user)
1067 {:ok, _user_relationships} = User.mute(user, muted_user)
1069 assert User.mutes?(user, muted_user)
1070 assert User.muted_notifications?(user, muted_user)
1074 user = insert(:user)
1075 muted_user = insert(:user)
1077 {:ok, _user_relationships} = User.mute(user, muted_user, %{expires_in: 60})
1078 assert User.mutes?(user, muted_user)
1080 worker = Pleroma.Workers.MuteExpireWorker
1081 args = %{"op" => "unmute_user", "muter_id" => user.id, "mutee_id" => muted_user.id}
1088 assert :ok = perform_job(worker, args)
1090 refute User.mutes?(user, muted_user)
1091 refute User.muted_notifications?(user, muted_user)
1094 test "it unmutes users" do
1095 user = insert(:user)
1096 muted_user = insert(:user)
1098 {:ok, _user_relationships} = User.mute(user, muted_user)
1099 {:ok, _user_mute} = User.unmute(user, muted_user)
1101 refute User.mutes?(user, muted_user)
1102 refute User.muted_notifications?(user, muted_user)
1105 test "it unmutes users by id" do
1106 user = insert(:user)
1107 muted_user = insert(:user)
1109 {:ok, _user_relationships} = User.mute(user, muted_user)
1110 {:ok, _user_mute} = User.unmute(user.id, muted_user.id)
1112 refute User.mutes?(user, muted_user)
1113 refute User.muted_notifications?(user, muted_user)
1116 test "it mutes user without notifications" do
1117 user = insert(:user)
1118 muted_user = insert(:user)
1120 refute User.mutes?(user, muted_user)
1121 refute User.muted_notifications?(user, muted_user)
1123 {:ok, _user_relationships} = User.mute(user, muted_user, %{notifications: false})
1125 assert User.mutes?(user, muted_user)
1126 refute User.muted_notifications?(user, muted_user)
1130 describe "blocks" do
1131 test "it blocks people" do
1132 user = insert(:user)
1133 blocked_user = insert(:user)
1135 refute User.blocks?(user, blocked_user)
1137 {:ok, _user_relationship} = User.block(user, blocked_user)
1139 assert User.blocks?(user, blocked_user)
1142 test "it unblocks users" do
1143 user = insert(:user)
1144 blocked_user = insert(:user)
1146 {:ok, _user_relationship} = User.block(user, blocked_user)
1147 {:ok, _user_block} = User.unblock(user, blocked_user)
1149 refute User.blocks?(user, blocked_user)
1152 test "blocks tear down cyclical follow relationships" do
1153 blocker = insert(:user)
1154 blocked = insert(:user)
1156 {:ok, blocker, blocked} = User.follow(blocker, blocked)
1157 {:ok, blocked, blocker} = User.follow(blocked, blocker)
1159 assert User.following?(blocker, blocked)
1160 assert User.following?(blocked, blocker)
1162 {:ok, _user_relationship} = User.block(blocker, blocked)
1163 blocked = User.get_cached_by_id(blocked.id)
1165 assert User.blocks?(blocker, blocked)
1167 refute User.following?(blocker, blocked)
1168 refute User.following?(blocked, blocker)
1171 test "blocks tear down blocker->blocked follow relationships" do
1172 blocker = insert(:user)
1173 blocked = insert(:user)
1175 {:ok, blocker, blocked} = User.follow(blocker, blocked)
1177 assert User.following?(blocker, blocked)
1178 refute User.following?(blocked, blocker)
1180 {:ok, _user_relationship} = User.block(blocker, blocked)
1181 blocked = User.get_cached_by_id(blocked.id)
1183 assert User.blocks?(blocker, blocked)
1185 refute User.following?(blocker, blocked)
1186 refute User.following?(blocked, blocker)
1189 test "blocks tear down blocked->blocker follow relationships" do
1190 blocker = insert(:user)
1191 blocked = insert(:user)
1193 {:ok, blocked, blocker} = User.follow(blocked, blocker)
1195 refute User.following?(blocker, blocked)
1196 assert User.following?(blocked, blocker)
1198 {:ok, _user_relationship} = User.block(blocker, blocked)
1199 blocked = User.get_cached_by_id(blocked.id)
1201 assert User.blocks?(blocker, blocked)
1203 refute User.following?(blocker, blocked)
1204 refute User.following?(blocked, blocker)
1207 test "blocks tear down blocked->blocker subscription relationships" do
1208 blocker = insert(:user)
1209 blocked = insert(:user)
1211 {:ok, _subscription} = User.subscribe(blocked, blocker)
1213 assert User.subscribed_to?(blocked, blocker)
1214 refute User.subscribed_to?(blocker, blocked)
1216 {:ok, _user_relationship} = User.block(blocker, blocked)
1218 assert User.blocks?(blocker, blocked)
1219 refute User.subscribed_to?(blocker, blocked)
1220 refute User.subscribed_to?(blocked, blocker)
1224 describe "domain blocking" do
1225 test "blocks domains" do
1226 user = insert(:user)
1227 collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
1229 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
1231 assert User.blocks?(user, collateral_user)
1234 test "does not block domain with same end" do
1235 user = insert(:user)
1238 insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
1240 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
1242 refute User.blocks?(user, collateral_user)
1245 test "does not block domain with same end if wildcard added" do
1246 user = insert(:user)
1249 insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
1251 {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
1253 refute User.blocks?(user, collateral_user)
1256 test "blocks domain with wildcard for subdomain" do
1257 user = insert(:user)
1259 user_from_subdomain =
1260 insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})
1262 user_with_two_subdomains =
1264 ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
1267 user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
1269 {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
1271 assert User.blocks?(user, user_from_subdomain)
1272 assert User.blocks?(user, user_with_two_subdomains)
1273 assert User.blocks?(user, user_domain)
1276 test "unblocks domains" do
1277 user = insert(:user)
1278 collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
1280 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
1281 {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")
1283 refute User.blocks?(user, collateral_user)
1286 test "follows take precedence over domain blocks" do
1287 user = insert(:user)
1288 good_eggo = insert(:user, %{ap_id: "https://meanies.social/user/cuteposter"})
1290 {:ok, user} = User.block_domain(user, "meanies.social")
1291 {:ok, user, good_eggo} = User.follow(user, good_eggo)
1293 refute User.blocks?(user, good_eggo)
1297 describe "get_recipients_from_activity" do
1298 test "works for announces" do
1299 actor = insert(:user)
1300 user = insert(:user, local: true)
1302 {:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
1303 {:ok, announce} = CommonAPI.repeat(activity.id, user)
1305 recipients = User.get_recipients_from_activity(announce)
1307 assert user in recipients
1310 test "get recipients" do
1311 actor = insert(:user)
1312 user = insert(:user, local: true)
1313 user_two = insert(:user, local: false)
1314 addressed = insert(:user, local: true)
1315 addressed_remote = insert(:user, local: false)
1318 CommonAPI.post(actor, %{
1319 status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
1322 assert Enum.map([actor, addressed], & &1.ap_id) --
1323 Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
1325 {:ok, user, actor} = User.follow(user, actor)
1326 {:ok, _user_two, _actor} = User.follow(user_two, actor)
1327 recipients = User.get_recipients_from_activity(activity)
1328 assert length(recipients) == 3
1329 assert user in recipients
1330 assert addressed in recipients
1333 test "has following" do
1334 actor = insert(:user)
1335 user = insert(:user)
1336 user_two = insert(:user)
1337 addressed = insert(:user, local: true)
1340 CommonAPI.post(actor, %{
1341 status: "hey @#{addressed.nickname}"
1344 assert Enum.map([actor, addressed], & &1.ap_id) --
1345 Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
1347 {:ok, _actor, _user} = User.follow(actor, user)
1348 {:ok, _actor, _user_two} = User.follow(actor, user_two)
1349 recipients = User.get_recipients_from_activity(activity)
1350 assert length(recipients) == 2
1351 assert addressed in recipients
1355 describe ".set_activation" do
1356 test "can de-activate then re-activate a user" do
1357 user = insert(:user)
1358 assert user.is_active
1359 {:ok, user} = User.set_activation(user, false)
1360 refute user.is_active
1361 {:ok, user} = User.set_activation(user, true)
1362 assert user.is_active
1365 test "hide a user from followers" do
1366 user = insert(:user)
1367 user2 = insert(:user)
1369 {:ok, user, user2} = User.follow(user, user2)
1370 {:ok, _user} = User.set_activation(user, false)
1372 user2 = User.get_cached_by_id(user2.id)
1374 assert user2.follower_count == 0
1375 assert [] = User.get_followers(user2)
1378 test "hide a user from friends" do
1379 user = insert(:user)
1380 user2 = insert(:user)
1382 {:ok, user2, user} = User.follow(user2, user)
1383 assert user2.following_count == 1
1384 assert User.following_count(user2) == 1
1386 {:ok, _user} = User.set_activation(user, false)
1388 user2 = User.get_cached_by_id(user2.id)
1390 assert refresh_record(user2).following_count == 0
1391 assert user2.following_count == 0
1392 assert User.following_count(user2) == 0
1393 assert [] = User.get_friends(user2)
1396 test "hide a user's statuses from timelines and notifications" do
1397 user = insert(:user)
1398 user2 = insert(:user)
1400 {:ok, user2, user} = User.follow(user2, user)
1402 {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{user2.nickname}"})
1404 activity = Repo.preload(activity, :bookmark)
1406 [notification] = Pleroma.Notification.for_user(user2)
1407 assert notification.activity.id == activity.id
1409 assert [activity] == ActivityPub.fetch_public_activities(%{}) |> Repo.preload(:bookmark)
1411 assert [%{activity | thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
1412 ActivityPub.fetch_activities([user2.ap_id | User.following(user2)], %{
1416 {:ok, _user} = User.set_activation(user, false)
1418 assert [] == ActivityPub.fetch_public_activities(%{})
1419 assert [] == Pleroma.Notification.for_user(user2)
1422 ActivityPub.fetch_activities([user2.ap_id | User.following(user2)], %{
1428 describe "approve" do
1429 test "approves a user" do
1430 user = insert(:user, is_approved: false)
1431 refute user.is_approved
1432 {:ok, user} = User.approve(user)
1433 assert user.is_approved
1436 test "approves a list of users" do
1437 unapproved_users = [
1438 insert(:user, is_approved: false),
1439 insert(:user, is_approved: false),
1440 insert(:user, is_approved: false)
1443 {:ok, users} = User.approve(unapproved_users)
1445 assert Enum.count(users) == 3
1447 Enum.each(users, fn user ->
1448 assert user.is_approved
1452 test "it sends welcome email if it is set" do
1453 clear_config([:welcome, :email, :enabled], true)
1454 clear_config([:welcome, :email, :sender], "tester@test.me")
1456 user = insert(:user, is_approved: false)
1457 welcome_user = insert(:user, email: "tester@test.me")
1458 instance_name = Pleroma.Config.get([:instance, :name])
1462 ObanHelpers.perform_all()
1465 from: {instance_name, welcome_user.email},
1466 to: {user.name, user.email},
1467 html_body: "Welcome to #{instance_name}"
1471 test "approving an approved user does not trigger post-register actions" do
1472 clear_config([:welcome, :email, :enabled], true)
1474 user = insert(:user, is_approved: true)
1477 ObanHelpers.perform_all()
1479 assert_no_email_sent()
1483 describe "confirm" do
1484 test "confirms a user" do
1485 user = insert(:user, is_confirmed: false)
1486 refute user.is_confirmed
1487 {:ok, user} = User.confirm(user)
1488 assert user.is_confirmed
1491 test "confirms a list of users" do
1492 unconfirmed_users = [
1493 insert(:user, is_confirmed: false),
1494 insert(:user, is_confirmed: false),
1495 insert(:user, is_confirmed: false)
1498 {:ok, users} = User.confirm(unconfirmed_users)
1500 assert Enum.count(users) == 3
1502 Enum.each(users, fn user ->
1503 assert user.is_confirmed
1507 test "sends approval emails when `is_approved: false`" do
1508 admin = insert(:user, is_admin: true)
1509 user = insert(:user, is_confirmed: false, is_approved: false)
1512 ObanHelpers.perform_all()
1514 user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
1515 admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)
1517 notify_email = Pleroma.Config.get([:instance, :notify_email])
1518 instance_name = Pleroma.Config.get([:instance, :name])
1520 # User approval email
1522 from: {instance_name, notify_email},
1523 to: {user.name, user.email},
1524 html_body: user_email.html_body
1529 from: {instance_name, notify_email},
1530 to: {admin.name, admin.email},
1531 html_body: admin_email.html_body
1535 test "confirming a confirmed user does not trigger post-register actions" do
1536 user = insert(:user, is_confirmed: true, is_approved: false)
1539 ObanHelpers.perform_all()
1541 assert_no_email_sent()
1545 describe "delete" do
1547 {:ok, user} = insert(:user) |> User.set_cache()
1552 setup do: clear_config([:instance, :federating])
1554 test ".delete_user_activities deletes all create activities", %{user: user} do
1555 {:ok, activity} = CommonAPI.post(user, %{status: "2hu"})
1557 User.delete_user_activities(user)
1559 # TODO: Test removal favorites, repeats, delete activities.
1560 refute Activity.get_by_id(activity.id)
1563 test "it deactivates a user, all follow relationships and all activities", %{user: user} do
1564 follower = insert(:user)
1565 {:ok, follower, user} = User.follow(follower, user)
1567 locked_user = insert(:user, name: "locked", is_locked: true)
1568 {:ok, _, _} = User.follow(user, locked_user, :follow_pending)
1570 object = insert(:note, user: user)
1571 activity = insert(:note_activity, user: user, note: object)
1573 object_two = insert(:note, user: follower)
1574 activity_two = insert(:note_activity, user: follower, note: object_two)
1576 {:ok, like} = CommonAPI.favorite(user, activity_two.id)
1577 {:ok, like_two} = CommonAPI.favorite(follower, activity.id)
1578 {:ok, repeat} = CommonAPI.repeat(activity_two.id, user)
1580 {:ok, job} = User.delete(user)
1581 {:ok, _user} = ObanHelpers.perform(job)
1583 follower = User.get_cached_by_id(follower.id)
1585 refute User.following?(follower, user)
1586 assert %{is_active: false} = User.get_by_id(user.id)
1588 assert [] == User.get_follow_requests(locked_user)
1592 |> Activity.Queries.by_actor()
1594 |> Enum.map(fn act -> act.data["type"] end)
1596 assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)
1598 refute Activity.get_by_id(activity.id)
1599 refute Activity.get_by_id(like.id)
1600 refute Activity.get_by_id(like_two.id)
1601 refute Activity.get_by_id(repeat.id)
1605 test "delete/1 when confirmation is pending deletes the user" do
1606 clear_config([:instance, :account_activation_required], true)
1607 user = insert(:user, is_confirmed: false)
1609 {:ok, job} = User.delete(user)
1610 {:ok, _} = ObanHelpers.perform(job)
1612 refute User.get_cached_by_id(user.id)
1613 refute User.get_by_id(user.id)
1616 test "delete/1 when approval is pending deletes the user" do
1617 user = insert(:user, is_approved: false)
1619 {:ok, job} = User.delete(user)
1620 {:ok, _} = ObanHelpers.perform(job)
1622 refute User.get_cached_by_id(user.id)
1623 refute User.get_by_id(user.id)
1626 test "delete/1 purges a user when they wouldn't be fully deleted" do
1631 password_hash: "pdfk2$1b3n159001",
1632 keys: "RSA begin buplic key",
1633 public_key: "--PRIVATE KEYE--",
1634 avatar: %{"a" => "b"},
1636 banner: %{"a" => "b"},
1637 background: %{"a" => "b"},
1640 following_count: 9001,
1642 is_confirmed: false,
1643 password_reset_pending: true,
1645 registration_reason: "ahhhhh",
1646 confirmation_token: "qqqq",
1647 domain_blocks: ["lain.com"],
1652 mascot: %{"a" => "b"},
1653 emoji: %{"a" => "b"},
1654 pleroma_settings_store: %{"q" => "x"},
1655 fields: [%{"gg" => "qq"}],
1656 raw_fields: [%{"gg" => "qq"}],
1657 is_discoverable: true,
1658 also_known_as: ["https://lol.olo/users/loll"]
1661 {:ok, job} = User.delete(user)
1662 {:ok, _} = ObanHelpers.perform(job)
1663 user = User.get_by_id(user.id)
1675 last_refreshed_at: nil,
1676 last_digest_emailed_at: nil,
1684 password_reset_pending: false,
1686 registration_reason: nil,
1687 confirmation_token: nil,
1691 is_moderator: false,
1695 pleroma_settings_store: %{},
1698 is_discoverable: false,
1703 test "get_public_key_for_ap_id fetches a user that's not in the db" do
1704 assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
1707 describe "per-user rich-text filtering" do
1708 test "html_filter_policy returns default policies, when rich-text is enabled" do
1709 user = insert(:user)
1711 assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
1714 test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
1715 user = insert(:user, no_rich_text: true)
1717 assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
1721 describe "caching" do
1722 test "invalidate_cache works" do
1723 user = insert(:user)
1725 User.set_cache(user)
1726 User.invalidate_cache(user)
1728 {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1729 {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
1732 test "User.delete() plugs any possible zombie objects" do
1733 user = insert(:user)
1735 {:ok, job} = User.delete(user)
1736 {:ok, _} = ObanHelpers.perform(job)
1738 {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
1740 assert cached_user != user
1742 {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")
1744 assert cached_user != user
1748 describe "account_status/1" do
1749 setup do: clear_config([:instance, :account_activation_required])
1751 test "return confirmation_pending for unconfirm user" do
1752 clear_config([:instance, :account_activation_required], true)
1753 user = insert(:user, is_confirmed: false)
1754 assert User.account_status(user) == :confirmation_pending
1757 test "return active for confirmed user" do
1758 clear_config([:instance, :account_activation_required], true)
1759 user = insert(:user, is_confirmed: true)
1760 assert User.account_status(user) == :active
1763 test "return active for remote user" do
1764 user = insert(:user, local: false)
1765 assert User.account_status(user) == :active
1768 test "returns :password_reset_pending for user with reset password" do
1769 user = insert(:user, password_reset_pending: true)
1770 assert User.account_status(user) == :password_reset_pending
1773 test "returns :deactivated for deactivated user" do
1774 user = insert(:user, local: true, is_confirmed: true, is_active: false)
1775 assert User.account_status(user) == :deactivated
1778 test "returns :approval_pending for unapproved user" do
1779 user = insert(:user, local: true, is_approved: false)
1780 assert User.account_status(user) == :approval_pending
1782 user = insert(:user, local: true, is_confirmed: false, is_approved: false)
1783 assert User.account_status(user) == :approval_pending
1787 describe "superuser?/1" do
1788 test "returns false for unprivileged users" do
1789 user = insert(:user, local: true)
1791 refute User.superuser?(user)
1794 test "returns false for remote users" do
1795 user = insert(:user, local: false)
1796 remote_admin_user = insert(:user, local: false, is_admin: true)
1798 refute User.superuser?(user)
1799 refute User.superuser?(remote_admin_user)
1802 test "returns true for local moderators" do
1803 user = insert(:user, local: true, is_moderator: true)
1805 assert User.superuser?(user)
1808 test "returns true for local admins" do
1809 user = insert(:user, local: true, is_admin: true)
1811 assert User.superuser?(user)
1815 describe "invisible?/1" do
1816 test "returns true for an invisible user" do
1817 user = insert(:user, local: true, invisible: true)
1819 assert User.invisible?(user)
1822 test "returns false for a non-invisible user" do
1823 user = insert(:user, local: true)
1825 refute User.invisible?(user)
1829 describe "visible_for/2" do
1830 test "returns true when the account is itself" do
1831 user = insert(:user, local: true)
1833 assert User.visible_for(user, user) == :visible
1836 test "returns false when the account is unconfirmed and confirmation is required" do
1837 clear_config([:instance, :account_activation_required], true)
1839 user = insert(:user, local: true, is_confirmed: false)
1840 other_user = insert(:user, local: true)
1842 refute User.visible_for(user, other_user) == :visible
1845 test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
1846 clear_config([:instance, :account_activation_required], true)
1848 user = insert(:user, local: false, is_confirmed: false)
1849 other_user = insert(:user, local: true)
1851 assert User.visible_for(user, other_user) == :visible
1854 test "returns true when the account is unconfirmed and being viewed by a privileged account (confirmation required)" do
1855 clear_config([:instance, :account_activation_required], true)
1857 user = insert(:user, local: true, is_confirmed: false)
1858 other_user = insert(:user, local: true, is_admin: true)
1860 assert User.visible_for(user, other_user) == :visible
1864 describe "parse_bio/2" do
1865 test "preserves hosts in user links text" do
1866 remote_user = insert(:user, local: false, nickname: "nick@domain.com")
1867 user = insert(:user)
1868 bio = "A.k.a. @nick@domain.com"
1871 ~s(A.k.a. <span class="h-card"><a class="u-url mention" data-user="#{remote_user.id}" href="#{
1873 }" rel="ugc">@<span>nick@domain.com</span></a></span>)
1875 assert expected_text == User.parse_bio(bio, user)
1878 test "Adds rel=me on linkbacked urls" do
1879 user = insert(:user, ap_id: "https://social.example.org/users/lain")
1881 bio = "http://example.com/rel_me/null"
1882 expected_text = "<a href=\"#{bio}\">#{bio}</a>"
1883 assert expected_text == User.parse_bio(bio, user)
1885 bio = "http://example.com/rel_me/link"
1886 expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
1887 assert expected_text == User.parse_bio(bio, user)
1889 bio = "http://example.com/rel_me/anchor"
1890 expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
1891 assert expected_text == User.parse_bio(bio, user)
1895 test "follower count is updated when a follower is blocked" do
1896 user = insert(:user)
1897 follower = insert(:user)
1898 follower2 = insert(:user)
1899 follower3 = insert(:user)
1901 {:ok, follower, user} = User.follow(follower, user)
1902 {:ok, _follower2, _user} = User.follow(follower2, user)
1903 {:ok, _follower3, _user} = User.follow(follower3, user)
1905 {:ok, _user_relationship} = User.block(user, follower)
1906 user = refresh_record(user)
1908 assert user.follower_count == 2
1911 describe "list_inactive_users_query/1" do
1912 defp days_ago(days) do
1914 NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
1915 -days * 60 * 60 * 24,
1920 test "Users are inactive by default" do
1924 Enum.map(1..total, fn _ ->
1925 insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
1928 inactive_users_ids =
1929 Pleroma.User.list_inactive_users_query()
1930 |> Pleroma.Repo.all()
1931 |> Enum.map(& &1.id)
1933 Enum.each(users, fn user ->
1934 assert user.id in inactive_users_ids
1938 test "Only includes users who has no recent activity" do
1942 Enum.map(1..total, fn _ ->
1943 insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
1946 {inactive, active} = Enum.split(users, trunc(total / 2))
1948 Enum.map(active, fn user ->
1949 to = Enum.random(users -- [user])
1952 CommonAPI.post(user, %{
1953 status: "hey @#{to.nickname}"
1957 inactive_users_ids =
1958 Pleroma.User.list_inactive_users_query()
1959 |> Pleroma.Repo.all()
1960 |> Enum.map(& &1.id)
1962 Enum.each(active, fn user ->
1963 refute user.id in inactive_users_ids
1966 Enum.each(inactive, fn user ->
1967 assert user.id in inactive_users_ids
1971 test "Only includes users with no read notifications" do
1975 Enum.map(1..total, fn _ ->
1976 insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
1979 [sender | recipients] = users
1980 {inactive, active} = Enum.split(recipients, trunc(total / 2))
1982 Enum.each(recipients, fn to ->
1984 CommonAPI.post(sender, %{
1985 status: "hey @#{to.nickname}"
1989 CommonAPI.post(sender, %{
1990 status: "hey again @#{to.nickname}"
1994 Enum.each(active, fn user ->
1995 [n1, _n2] = Pleroma.Notification.for_user(user)
1996 {:ok, _} = Pleroma.Notification.read_one(user, n1.id)
1999 inactive_users_ids =
2000 Pleroma.User.list_inactive_users_query()
2001 |> Pleroma.Repo.all()
2002 |> Enum.map(& &1.id)
2004 Enum.each(active, fn user ->
2005 refute user.id in inactive_users_ids
2008 Enum.each(inactive, fn user ->
2009 assert user.id in inactive_users_ids
2014 describe "ensure_keys_present" do
2015 test "it creates keys for a user and stores them in info" do
2016 user = insert(:user)
2017 refute is_binary(user.keys)
2018 {:ok, user} = User.ensure_keys_present(user)
2019 assert is_binary(user.keys)
2022 test "it doesn't create keys if there already are some" do
2023 user = insert(:user, keys: "xxx")
2024 {:ok, user} = User.ensure_keys_present(user)
2025 assert user.keys == "xxx"
2029 describe "get_ap_ids_by_nicknames" do
2030 test "it returns a list of AP ids for a given set of nicknames" do
2031 user = insert(:user)
2032 user_two = insert(:user)
2034 ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
2035 assert length(ap_ids) == 2
2036 assert user.ap_id in ap_ids
2037 assert user_two.ap_id in ap_ids
2041 describe "sync followers count" do
2043 user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
2044 user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
2045 insert(:user, local: true)
2046 insert(:user, local: false, is_active: false)
2047 {:ok, user1: user1, user2: user2}
2050 test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
2051 [fdb_user1] = User.external_users(limit: 1)
2053 assert fdb_user1.ap_id
2054 assert fdb_user1.ap_id == user1.ap_id
2055 assert fdb_user1.id == user1.id
2057 [fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)
2059 assert fdb_user2.ap_id
2060 assert fdb_user2.ap_id == user2.ap_id
2061 assert fdb_user2.id == user2.id
2063 assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
2067 describe "is_internal_user?/1" do
2068 test "non-internal user returns false" do
2069 user = insert(:user)
2070 refute User.is_internal_user?(user)
2073 test "user with no nickname returns true" do
2074 user = insert(:user, %{nickname: nil})
2075 assert User.is_internal_user?(user)
2078 test "user with internal-prefixed nickname returns true" do
2079 user = insert(:user, %{nickname: "internal.test"})
2080 assert User.is_internal_user?(user)
2084 describe "update_and_set_cache/1" do
2085 test "returns error when user is stale instead Ecto.StaleEntryError" do
2086 user = insert(:user)
2088 changeset = Ecto.Changeset.change(user, bio: "test")
2092 assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
2093 User.update_and_set_cache(changeset)
2096 test "performs update cache if user updated" do
2097 user = insert(:user)
2098 assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
2100 changeset = Ecto.Changeset.change(user, bio: "test-bio")
2102 assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
2103 assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
2104 assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
2108 describe "following/followers synchronization" do
2109 setup do: clear_config([:instance, :external_user_synchronization])
2111 test "updates the counters normally on following/getting a follow when disabled" do
2112 clear_config([:instance, :external_user_synchronization], false)
2113 user = insert(:user)
2118 follower_address: "http://localhost:4001/users/masto_closed/followers",
2119 following_address: "http://localhost:4001/users/masto_closed/following",
2123 assert other_user.following_count == 0
2124 assert other_user.follower_count == 0
2126 {:ok, user, other_user} = Pleroma.User.follow(user, other_user)
2128 assert user.following_count == 1
2129 assert other_user.follower_count == 1
2132 test "syncronizes the counters with the remote instance for the followed when enabled" do
2133 clear_config([:instance, :external_user_synchronization], false)
2135 user = insert(:user)
2140 follower_address: "http://localhost:4001/users/masto_closed/followers",
2141 following_address: "http://localhost:4001/users/masto_closed/following",
2145 assert other_user.following_count == 0
2146 assert other_user.follower_count == 0
2148 clear_config([:instance, :external_user_synchronization], true)
2149 {:ok, _user, other_user} = User.follow(user, other_user)
2151 assert other_user.follower_count == 437
2154 test "syncronizes the counters with the remote instance for the follower when enabled" do
2155 clear_config([:instance, :external_user_synchronization], false)
2157 user = insert(:user)
2162 follower_address: "http://localhost:4001/users/masto_closed/followers",
2163 following_address: "http://localhost:4001/users/masto_closed/following",
2167 assert other_user.following_count == 0
2168 assert other_user.follower_count == 0
2170 clear_config([:instance, :external_user_synchronization], true)
2171 {:ok, other_user, _user} = User.follow(other_user, user)
2173 assert other_user.following_count == 152
2177 describe "change_email/2" do
2179 [user: insert(:user)]
2182 test "blank email returns error", %{user: user} do
2183 assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
2184 assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
2187 test "non unique email returns error", %{user: user} do
2188 %{email: email} = insert(:user)
2190 assert {:error, %{errors: [email: {"has already been taken", _}]}} =
2191 User.change_email(user, email)
2194 test "invalid email returns error", %{user: user} do
2195 assert {:error, %{errors: [email: {"has invalid format", _}]}} =
2196 User.change_email(user, "cofe")
2199 test "changes email", %{user: user} do
2200 assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
2204 describe "get_cached_by_nickname_or_id" do
2206 local_user = insert(:user)
2207 remote_user = insert(:user, nickname: "nickname@example.com", local: false)
2209 [local_user: local_user, remote_user: remote_user]
2212 setup do: clear_config([:instance, :limit_to_local_content])
2214 test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
2215 remote_user: remote_user
2217 clear_config([:instance, :limit_to_local_content], false)
2218 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
2220 clear_config([:instance, :limit_to_local_content], true)
2221 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
2223 clear_config([:instance, :limit_to_local_content], :unauthenticated)
2224 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
2227 test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
2228 %{remote_user: remote_user} do
2229 clear_config([:instance, :limit_to_local_content], :unauthenticated)
2230 assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
2233 test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
2234 %{remote_user: remote_user, local_user: local_user} do
2235 clear_config([:instance, :limit_to_local_content], :unauthenticated)
2236 assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
2239 test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
2240 %{remote_user: remote_user} do
2241 clear_config([:instance, :limit_to_local_content], true)
2242 assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
2245 test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
2246 %{local_user: local_user} do
2247 clear_config([:instance, :limit_to_local_content], false)
2248 assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
2250 clear_config([:instance, :limit_to_local_content], true)
2251 assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
2253 clear_config([:instance, :limit_to_local_content], :unauthenticated)
2254 assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
2258 describe "update_email_notifications/2" do
2260 user = insert(:user, email_notifications: %{"digest" => true})
2265 test "Notifications are updated", %{user: user} do
2266 true = user.email_notifications["digest"]
2267 assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
2268 assert result.email_notifications["digest"] == false
2272 describe "local_nickname/1" do
2273 test "returns nickname without host" do
2274 assert User.local_nickname("@mentioned") == "mentioned"
2275 assert User.local_nickname("a_local_nickname") == "a_local_nickname"
2276 assert User.local_nickname("nickname@host.com") == "nickname"
2280 describe "full_nickname/1" do
2281 test "returns fully qualified nickname for local and remote users" do
2283 insert(:user, nickname: "local_user", ap_id: "https://somehost.com/users/local_user")
2285 remote_user = insert(:user, nickname: "remote@host.com", local: false)
2287 assert User.full_nickname(local_user) == "local_user@somehost.com"
2288 assert User.full_nickname(remote_user) == "remote@host.com"
2291 test "strips leading @ from mentions" do
2292 assert User.full_nickname("@mentioned") == "mentioned"
2293 assert User.full_nickname("@nickname@host.com") == "nickname@host.com"
2296 test "does not modify nicknames" do
2297 assert User.full_nickname("nickname") == "nickname"
2298 assert User.full_nickname("nickname@host.com") == "nickname@host.com"
2302 test "avatar fallback" do
2303 user = insert(:user)
2304 assert User.avatar_url(user) =~ "/images/avi.png"
2306 clear_config([:assets, :default_user_avatar], "avatar.png")
2308 user = User.get_cached_by_nickname_or_id(user.nickname)
2309 assert User.avatar_url(user) =~ "avatar.png"
2311 assert User.avatar_url(user, no_default: true) == nil
2314 test "get_host/1" do
2315 user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
2316 assert User.get_host(user) == "lain.com"
2319 test "update_last_active_at/1" do
2320 user = insert(:user)
2321 assert is_nil(user.last_active_at)
2323 test_started_at = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
2325 assert {:ok, user} = User.update_last_active_at(user)
2327 assert user.last_active_at >= test_started_at
2328 assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2331 NaiveDateTime.utc_now()
2332 |> NaiveDateTime.add(-:timer.hours(24), :millisecond)
2333 |> NaiveDateTime.truncate(:second)
2335 assert {:ok, user} =
2337 |> cast(%{last_active_at: last_active_at}, [:last_active_at])
2338 |> User.update_and_set_cache()
2340 assert user.last_active_at == last_active_at
2341 assert {:ok, user} = User.update_last_active_at(user)
2342 assert user.last_active_at >= test_started_at
2343 assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2346 test "active_user_count/1" do
2348 insert(:user, %{local: false})
2349 insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -5)})
2350 insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -3)})
2351 insert(:user, %{last_active_at: NaiveDateTime.utc_now()})
2353 assert User.active_user_count() == 2
2354 assert User.active_user_count(6) == 3
2355 assert User.active_user_count(1) == 1
2360 user = insert(:user)
2362 [user: user, object_id: object_id_from_created_activity(user)]
2365 test "unique pins", %{user: user, object_id: object_id} do
2366 assert {:ok, %{pinned_objects: %{^object_id => pinned_at1} = pins} = updated_user} =
2367 User.add_pinned_object_id(user, object_id)
2369 assert Enum.count(pins) == 1
2371 assert {:ok, %{pinned_objects: %{^object_id => pinned_at2} = pins}} =
2372 User.add_pinned_object_id(updated_user, object_id)
2374 assert pinned_at1 == pinned_at2
2376 assert Enum.count(pins) == 1
2379 test "respects max_pinned_statuses limit", %{user: user, object_id: object_id} do
2380 clear_config([:instance, :max_pinned_statuses], 1)
2381 {:ok, updated} = User.add_pinned_object_id(user, object_id)
2383 object_id2 = object_id_from_created_activity(user)
2385 {:error, %{errors: errors}} = User.add_pinned_object_id(updated, object_id2)
2386 assert Keyword.has_key?(errors, :pinned_objects)
2389 test "remove_pinned_object_id/2", %{user: user, object_id: object_id} do
2390 assert {:ok, updated} = User.add_pinned_object_id(user, object_id)
2392 {:ok, after_remove} = User.remove_pinned_object_id(updated, object_id)
2393 assert after_remove.pinned_objects == %{}
2397 defp object_id_from_created_activity(user) do
2398 %{id: id} = insert(:note_activity, user: user)
2399 %{object: %{data: %{"id" => object_id}}} = Activity.get_by_id_with_object(id)