1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.UserTest do
6 alias Pleroma.Builders.UserBuilder
10 alias Pleroma.Web.CommonAPI
13 import Pleroma.Factory
16 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
20 describe "when tags are nil" do
21 test "tagging a user" do
22 user = insert(:user, %{tags: nil})
23 user = User.tag(user, ["cool", "dude"])
25 assert "cool" in user.tags
26 assert "dude" in user.tags
29 test "untagging a user" do
30 user = insert(:user, %{tags: nil})
31 user = User.untag(user, ["cool", "dude"])
33 assert user.tags == []
37 test "ap_id returns the activity pub id for the user" do
38 user = UserBuilder.build()
40 expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
42 assert expected_ap_id == User.ap_id(user)
45 test "ap_followers returns the followers collection for the user" do
46 user = UserBuilder.build()
48 expected_followers_collection = "#{User.ap_id(user)}/followers"
50 assert expected_followers_collection == User.ap_followers(user)
53 test "returns all pending follow requests" do
54 unlocked = insert(:user)
55 locked = insert(:user, %{info: %{locked: true}})
56 follower = insert(:user)
58 Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => unlocked.id})
59 Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => locked.id})
61 assert {:ok, []} = User.get_follow_requests(unlocked)
62 assert {:ok, [activity]} = User.get_follow_requests(locked)
67 test "follow_all follows mutliple users" do
69 followed_zero = insert(:user)
70 followed_one = insert(:user)
71 followed_two = insert(:user)
72 blocked = insert(:user)
73 not_followed = insert(:user)
74 reverse_blocked = insert(:user)
76 {:ok, user} = User.block(user, blocked)
77 {:ok, reverse_blocked} = User.block(reverse_blocked, user)
79 {:ok, user} = User.follow(user, followed_zero)
81 {:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])
83 assert User.following?(user, followed_one)
84 assert User.following?(user, followed_two)
85 assert User.following?(user, followed_zero)
86 refute User.following?(user, not_followed)
87 refute User.following?(user, blocked)
88 refute User.following?(user, reverse_blocked)
91 test "follow_all follows mutliple users without duplicating" do
93 followed_zero = insert(:user)
94 followed_one = insert(:user)
95 followed_two = insert(:user)
97 {:ok, user} = User.follow_all(user, [followed_zero, followed_one])
98 assert length(user.following) == 3
100 {:ok, user} = User.follow_all(user, [followed_one, followed_two])
101 assert length(user.following) == 4
104 test "follow takes a user and another user" do
106 followed = insert(:user)
108 {:ok, user} = User.follow(user, followed)
110 user = Repo.get(User, user.id)
112 followed = User.get_by_ap_id(followed.ap_id)
113 assert followed.info.follower_count == 1
115 assert User.ap_followers(followed) in user.following
118 test "can't follow a deactivated users" do
120 followed = insert(:user, info: %{deactivated: true})
122 {:error, _} = User.follow(user, followed)
125 test "can't follow a user who blocked us" do
126 blocker = insert(:user)
127 blockee = insert(:user)
129 {:ok, blocker} = User.block(blocker, blockee)
131 {:error, _} = User.follow(blockee, blocker)
134 test "local users do not automatically follow local locked accounts" do
135 follower = insert(:user, info: %{locked: true})
136 followed = insert(:user, info: %{locked: true})
138 {:ok, follower} = User.maybe_direct_follow(follower, followed)
140 refute User.following?(follower, followed)
143 # This is a somewhat useless test.
144 # test "following a remote user will ensure a websub subscription is present" do
145 # user = insert(:user)
146 # {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")
148 # assert followed.local == false
150 # {:ok, user} = User.follow(user, followed)
151 # assert User.ap_followers(followed) in user.following
153 # query = from w in WebsubClientSubscription,
154 # where: w.topic == ^followed.info["topic"]
155 # websub = Repo.one(query)
160 test "unfollow takes a user and another user" do
161 followed = insert(:user)
162 user = insert(:user, %{following: [User.ap_followers(followed)]})
164 {:ok, user, _activity} = User.unfollow(user, followed)
166 user = Repo.get(User, user.id)
168 assert user.following == []
171 test "unfollow doesn't unfollow yourself" do
174 {:error, _} = User.unfollow(user, user)
176 user = Repo.get(User, user.id)
177 assert user.following == [user.ap_id]
180 test "test if a user is following another user" do
181 followed = insert(:user)
182 user = insert(:user, %{following: [User.ap_followers(followed)]})
184 assert User.following?(user, followed)
185 refute User.following?(followed, user)
188 describe "user registration" do
194 password_confirmation: "test",
195 email: "email@example.com"
198 test "it autofollows accounts that are set for it" do
200 remote_user = insert(:user, %{local: false})
202 Pleroma.Config.put([:instance, :autofollowed_nicknames], [
207 cng = User.register_changeset(%User{}, @full_user_data)
209 {:ok, registered_user} = User.register(cng)
211 assert User.following?(registered_user, user)
212 refute User.following?(registered_user, remote_user)
214 Pleroma.Config.put([:instance, :autofollowed_nicknames], [])
217 test "it sends a welcome message if it is set" do
218 welcome_user = insert(:user)
220 Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
221 Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")
223 cng = User.register_changeset(%User{}, @full_user_data)
224 {:ok, registered_user} = User.register(cng)
226 activity = Repo.one(Pleroma.Activity)
227 assert registered_user.ap_id in activity.recipients
228 assert activity.data["object"]["content"] =~ "cool site"
229 assert activity.actor == welcome_user.ap_id
231 Pleroma.Config.put([:instance, :welcome_user_nickname], nil)
232 Pleroma.Config.put([:instance, :welcome_message], nil)
235 test "it requires an email, name, nickname and password, bio is optional" do
238 |> Enum.each(fn key ->
239 params = Map.delete(@full_user_data, key)
240 changeset = User.register_changeset(%User{}, params)
242 assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
246 test "it restricts certain nicknames" do
247 [restricted_name | _] = Pleroma.Config.get([Pleroma.User, :restricted_nicknames])
249 assert is_bitstring(restricted_name)
253 |> Map.put(:nickname, restricted_name)
255 changeset = User.register_changeset(%User{}, params)
257 refute changeset.valid?
260 test "it sets the password_hash, ap_id and following fields" do
261 changeset = User.register_changeset(%User{}, @full_user_data)
263 assert changeset.valid?
265 assert is_binary(changeset.changes[:password_hash])
266 assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
268 assert changeset.changes[:following] == [
269 User.ap_followers(%User{nickname: @full_user_data.nickname})
272 assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
275 test "it ensures info is not nil" do
276 changeset = User.register_changeset(%User{}, @full_user_data)
278 assert changeset.valid?
284 refute is_nil(user.info)
288 describe "user registration, with :account_activation_required" do
294 password_confirmation: "test",
295 email: "email@example.com"
299 setting = Pleroma.Config.get([:instance, :account_activation_required])
302 Pleroma.Config.put([:instance, :account_activation_required], true)
303 on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
309 test "it creates unconfirmed user" do
310 changeset = User.register_changeset(%User{}, @full_user_data)
311 assert changeset.valid?
313 {:ok, user} = Repo.insert(changeset)
315 assert user.info.confirmation_pending
316 assert user.info.confirmation_token
319 test "it creates confirmed user if :confirmed option is given" do
320 changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
321 assert changeset.valid?
323 {:ok, user} = Repo.insert(changeset)
325 refute user.info.confirmation_pending
326 refute user.info.confirmation_token
330 describe "get_or_fetch/1" do
331 test "gets an existing user by nickname" do
333 fetched_user = User.get_or_fetch(user.nickname)
335 assert user == fetched_user
338 test "gets an existing user by ap_id" do
339 ap_id = "http://mastodon.example.org/users/admin"
345 nickname: "admin@mastodon.example.org",
350 fetched_user = User.get_or_fetch(ap_id)
351 freshed_user = refresh_record(user)
352 assert freshed_user == fetched_user
356 describe "fetching a user from nickname or trying to build one" do
357 test "gets an existing user" do
359 fetched_user = User.get_or_fetch_by_nickname(user.nickname)
361 assert user == fetched_user
364 test "gets an existing user, case insensitive" do
365 user = insert(:user, nickname: "nick")
366 fetched_user = User.get_or_fetch_by_nickname("NICK")
368 assert user == fetched_user
371 test "gets an existing user by fully qualified nickname" do
375 User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
377 assert user == fetched_user
380 test "gets an existing user by fully qualified nickname, case insensitive" do
381 user = insert(:user, nickname: "nick")
382 casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
384 fetched_user = User.get_or_fetch_by_nickname(casing_altered_fqn)
386 assert user == fetched_user
389 test "fetches an external user via ostatus if no user exists" do
390 fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
391 assert fetched_user.nickname == "shp@social.heldscal.la"
394 test "returns nil if no user could be fetched" do
395 fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
396 assert fetched_user == nil
399 test "returns nil for nonexistant local user" do
400 fetched_user = User.get_or_fetch_by_nickname("nonexistant")
401 assert fetched_user == nil
404 test "updates an existing user, if stale" do
405 a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
411 nickname: "admin@mastodon.example.org",
412 ap_id: "http://mastodon.example.org/users/admin",
413 last_refreshed_at: a_week_ago,
417 assert orig_user.last_refreshed_at == a_week_ago
419 user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
420 assert user.info.source_data["endpoints"]
422 refute user.last_refreshed_at == orig_user.last_refreshed_at
426 test "returns an ap_id for a user" do
429 assert User.ap_id(user) ==
430 Pleroma.Web.Router.Helpers.o_status_url(
431 Pleroma.Web.Endpoint,
437 test "returns an ap_followers link for a user" do
440 assert User.ap_followers(user) ==
441 Pleroma.Web.Router.Helpers.o_status_url(
442 Pleroma.Web.Endpoint,
448 describe "remote user creation changeset" do
454 info: %{some: "info"},
455 avatar: %{some: "avatar"}
458 test "it confirms validity" do
459 cs = User.remote_user_creation(@valid_remote)
463 test "it sets the follower_adress" do
464 cs = User.remote_user_creation(@valid_remote)
465 # remote users get a fake local follower address
466 assert cs.changes.follower_address ==
467 User.ap_followers(%User{nickname: @valid_remote[:nickname]})
470 test "it enforces the fqn format for nicknames" do
471 cs = User.remote_user_creation(%{@valid_remote | nickname: "bla"})
472 assert cs.changes.local == false
473 assert cs.changes.avatar
477 test "it has required fields" do
479 |> Enum.each(fn field ->
480 cs = User.remote_user_creation(Map.delete(@valid_remote, field))
485 test "it restricts some sizes" do
486 [bio: 5000, name: 100]
487 |> Enum.each(fn {field, size} ->
488 string = String.pad_leading(".", size)
489 cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
492 string = String.pad_leading(".", size + 1)
493 cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
499 describe "followers and friends" do
500 test "gets all followers for a given user" do
502 follower_one = insert(:user)
503 follower_two = insert(:user)
504 not_follower = insert(:user)
506 {:ok, follower_one} = User.follow(follower_one, user)
507 {:ok, follower_two} = User.follow(follower_two, user)
509 {:ok, res} = User.get_followers(user)
511 assert Enum.member?(res, follower_one)
512 assert Enum.member?(res, follower_two)
513 refute Enum.member?(res, not_follower)
516 test "gets all friends (followed users) for a given user" do
518 followed_one = insert(:user)
519 followed_two = insert(:user)
520 not_followed = insert(:user)
522 {:ok, user} = User.follow(user, followed_one)
523 {:ok, user} = User.follow(user, followed_two)
525 {:ok, res} = User.get_friends(user)
527 followed_one = User.get_by_ap_id(followed_one.ap_id)
528 followed_two = User.get_by_ap_id(followed_two.ap_id)
529 assert Enum.member?(res, followed_one)
530 assert Enum.member?(res, followed_two)
531 refute Enum.member?(res, not_followed)
535 describe "updating note and follower count" do
536 test "it sets the info->note_count property" do
539 user = User.get_by_ap_id(note.data["actor"])
541 assert user.info.note_count == 0
543 {:ok, user} = User.update_note_count(user)
545 assert user.info.note_count == 1
548 test "it increases the info->note_count property" do
550 user = User.get_by_ap_id(note.data["actor"])
552 assert user.info.note_count == 0
554 {:ok, user} = User.increase_note_count(user)
556 assert user.info.note_count == 1
558 {:ok, user} = User.increase_note_count(user)
560 assert user.info.note_count == 2
563 test "it decreases the info->note_count property" do
565 user = User.get_by_ap_id(note.data["actor"])
567 assert user.info.note_count == 0
569 {:ok, user} = User.increase_note_count(user)
571 assert user.info.note_count == 1
573 {:ok, user} = User.decrease_note_count(user)
575 assert user.info.note_count == 0
577 {:ok, user} = User.decrease_note_count(user)
579 assert user.info.note_count == 0
582 test "it sets the info->follower_count property" do
584 follower = insert(:user)
586 User.follow(follower, user)
588 assert user.info.follower_count == 0
590 {:ok, user} = User.update_follower_count(user)
592 assert user.info.follower_count == 1
596 describe "follow_import" do
597 test "it imports user followings from list" do
598 [user1, user2, user3] = insert_list(3, :user)
605 result = User.follow_import(user1, identifiers)
606 assert is_list(result)
607 assert result == [user2, user3]
612 test "it mutes people" do
614 muted_user = insert(:user)
616 refute User.mutes?(user, muted_user)
618 {:ok, user} = User.mute(user, muted_user)
620 assert User.mutes?(user, muted_user)
623 test "it unmutes users" do
625 muted_user = insert(:user)
627 {:ok, user} = User.mute(user, muted_user)
628 {:ok, user} = User.unmute(user, muted_user)
630 refute User.mutes?(user, muted_user)
635 test "it blocks people" do
637 blocked_user = insert(:user)
639 refute User.blocks?(user, blocked_user)
641 {:ok, user} = User.block(user, blocked_user)
643 assert User.blocks?(user, blocked_user)
646 test "it unblocks users" do
648 blocked_user = insert(:user)
650 {:ok, user} = User.block(user, blocked_user)
651 {:ok, user} = User.unblock(user, blocked_user)
653 refute User.blocks?(user, blocked_user)
656 test "blocks tear down cyclical follow relationships" do
657 blocker = insert(:user)
658 blocked = insert(:user)
660 {:ok, blocker} = User.follow(blocker, blocked)
661 {:ok, blocked} = User.follow(blocked, blocker)
663 assert User.following?(blocker, blocked)
664 assert User.following?(blocked, blocker)
666 {:ok, blocker} = User.block(blocker, blocked)
667 blocked = Repo.get(User, blocked.id)
669 assert User.blocks?(blocker, blocked)
671 refute User.following?(blocker, blocked)
672 refute User.following?(blocked, blocker)
675 test "blocks tear down blocker->blocked follow relationships" do
676 blocker = insert(:user)
677 blocked = insert(:user)
679 {:ok, blocker} = User.follow(blocker, blocked)
681 assert User.following?(blocker, blocked)
682 refute User.following?(blocked, blocker)
684 {:ok, blocker} = User.block(blocker, blocked)
685 blocked = Repo.get(User, blocked.id)
687 assert User.blocks?(blocker, blocked)
689 refute User.following?(blocker, blocked)
690 refute User.following?(blocked, blocker)
693 test "blocks tear down blocked->blocker follow relationships" do
694 blocker = insert(:user)
695 blocked = insert(:user)
697 {:ok, blocked} = User.follow(blocked, blocker)
699 refute User.following?(blocker, blocked)
700 assert User.following?(blocked, blocker)
702 {:ok, blocker} = User.block(blocker, blocked)
703 blocked = Repo.get(User, blocked.id)
705 assert User.blocks?(blocker, blocked)
707 refute User.following?(blocker, blocked)
708 refute User.following?(blocked, blocker)
712 describe "domain blocking" do
713 test "blocks domains" do
715 collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
717 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
719 assert User.blocks?(user, collateral_user)
722 test "unblocks domains" do
724 collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
726 {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
727 {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")
729 refute User.blocks?(user, collateral_user)
733 describe "blocks_import" do
734 test "it imports user blocks from list" do
735 [user1, user2, user3] = insert_list(3, :user)
742 result = User.blocks_import(user1, identifiers)
743 assert is_list(result)
744 assert result == [user2, user3]
748 test "get recipients from activity" do
749 actor = insert(:user)
750 user = insert(:user, local: true)
751 user_two = insert(:user, local: false)
752 addressed = insert(:user, local: true)
753 addressed_remote = insert(:user, local: false)
756 CommonAPI.post(actor, %{
757 "status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
760 assert Enum.map([actor, addressed], & &1.ap_id) --
761 Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
763 {:ok, user} = User.follow(user, actor)
764 {:ok, _user_two} = User.follow(user_two, actor)
765 recipients = User.get_recipients_from_activity(activity)
766 assert length(recipients) == 3
767 assert user in recipients
768 assert addressed in recipients
771 test ".deactivate can de-activate then re-activate a user" do
773 assert false == user.info.deactivated
774 {:ok, user} = User.deactivate(user)
775 assert true == user.info.deactivated
776 {:ok, user} = User.deactivate(user, false)
777 assert false == user.info.deactivated
780 test ".delete deactivates a user, all follow relationships and all create activities" do
782 followed = insert(:user)
783 follower = insert(:user)
785 {:ok, user} = User.follow(user, followed)
786 {:ok, follower} = User.follow(follower, user)
788 {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
789 {:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})
791 {:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
792 {:ok, _, _} = CommonAPI.favorite(activity.id, follower)
793 {:ok, _, _} = CommonAPI.repeat(activity.id, follower)
795 {:ok, _} = User.delete(user)
797 followed = Repo.get(User, followed.id)
798 follower = Repo.get(User, follower.id)
799 user = Repo.get(User, user.id)
801 assert user.info.deactivated
803 refute User.following?(user, followed)
804 refute User.following?(followed, follower)
806 # TODO: Remove favorites, repeats, delete activities.
808 refute Repo.get(Activity, activity.id)
811 test "get_public_key_for_ap_id fetches a user that's not in the db" do
812 assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
815 test "insert or update a user from given data" do
816 user = insert(:user, %{nickname: "nick@name.de"})
817 data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}
819 assert {:ok, %User{}} = User.insert_or_update_user(data)
822 describe "per-user rich-text filtering" do
823 test "html_filter_policy returns default policies, when rich-text is enabled" do
826 assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
829 test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
830 user = insert(:user, %{info: %{no_rich_text: true}})
832 assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
836 describe "caching" do
837 test "invalidate_cache works" do
839 _user_info = User.get_cached_user_info(user)
841 User.invalidate_cache(user)
843 {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
844 {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
845 {:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
848 test "User.delete() plugs any possible zombie objects" do
851 {:ok, _} = User.delete(user)
853 {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
855 assert cached_user != user
857 {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")
859 assert cached_user != user
863 describe "User.search" do
864 test "finds a user by full or partial nickname" do
865 user = insert(:user, %{nickname: "john"})
867 Enum.each(["john", "jo", "j"], fn query ->
868 assert user == User.search(query) |> List.first() |> Map.put(:search_rank, nil)
872 test "finds a user by full or partial name" do
873 user = insert(:user, %{name: "John Doe"})
875 Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
876 assert user == User.search(query) |> List.first() |> Map.put(:search_rank, nil)
880 test "finds users, preferring nickname matches over name matches" do
881 u1 = insert(:user, %{name: "lain", nickname: "nick1"})
882 u2 = insert(:user, %{nickname: "lain", name: "nick1"})
884 assert [u2.id, u1.id] == Enum.map(User.search("lain"), & &1.id)
887 test "finds users, considering density of matched tokens" do
888 u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
889 u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})
891 assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
894 test "finds users, ranking by similarity" do
895 u1 = insert(:user, %{name: "lain"})
896 _u2 = insert(:user, %{name: "ean"})
897 u3 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
898 u4 = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})
900 assert [u4.id, u3.id, u1.id] == Enum.map(User.search("lain@ple"), & &1.id)
903 test "finds users, handling misspelled requests" do
904 u1 = insert(:user, %{name: "lain"})
906 assert [u1.id] == Enum.map(User.search("laiin"), & &1.id)
909 test "finds users, boosting ranks of friends and followers" do
911 u2 = insert(:user, %{name: "Doe"})
912 follower = insert(:user, %{name: "Doe"})
913 friend = insert(:user, %{name: "Doe"})
915 {:ok, follower} = User.follow(follower, u1)
916 {:ok, u1} = User.follow(u1, friend)
918 assert [friend.id, follower.id, u2.id] == Enum.map(User.search("doe", false, u1), & &1.id)
921 test "finds a user whose name is nil" do
922 _user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
923 user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})
926 User.search("lain@pleroma.soykaf.com")
928 |> Map.put(:search_rank, nil)
931 test "does not yield false-positive matches" do
932 insert(:user, %{name: "John Doe"})
934 Enum.each(["mary", "a", ""], fn query ->
935 assert [] == User.search(query)
939 test "works with URIs" do
940 results = User.search("http://mastodon.example.org/users/admin", true)
941 result = results |> List.first()
943 user = User.get_by_ap_id("http://mastodon.example.org/users/admin")
945 assert length(results) == 1
946 assert user == result |> Map.put(:search_rank, nil)
950 test "auth_active?/1 works correctly" do
951 Pleroma.Config.put([:instance, :account_activation_required], true)
953 local_user = insert(:user, local: true, info: %{confirmation_pending: true})
954 confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
955 remote_user = insert(:user, local: false)
957 refute User.auth_active?(local_user)
958 assert User.auth_active?(confirmed_user)
959 assert User.auth_active?(remote_user)
961 Pleroma.Config.put([:instance, :account_activation_required], false)
964 describe "superuser?/1" do
965 test "returns false for unprivileged users" do
966 user = insert(:user, local: true)
968 refute User.superuser?(user)
971 test "returns false for remote users" do
972 user = insert(:user, local: false)
973 remote_admin_user = insert(:user, local: false, info: %{is_admin: true})
975 refute User.superuser?(user)
976 refute User.superuser?(remote_admin_user)
979 test "returns true for local moderators" do
980 user = insert(:user, local: true, info: %{is_moderator: true})
982 assert User.superuser?(user)
985 test "returns true for local admins" do
986 user = insert(:user, local: true, info: %{is_admin: true})
988 assert User.superuser?(user)
992 describe "visible_for?/2" do
993 test "returns true when the account is itself" do
994 user = insert(:user, local: true)
996 assert User.visible_for?(user, user)
999 test "returns false when the account is unauthenticated and auth is required" do
1000 Pleroma.Config.put([:instance, :account_activation_required], true)
1002 user = insert(:user, local: true, info: %{confirmation_pending: true})
1003 other_user = insert(:user, local: true)
1005 refute User.visible_for?(user, other_user)
1007 Pleroma.Config.put([:instance, :account_activation_required], false)
1010 test "returns true when the account is unauthenticated and auth is not required" do
1011 user = insert(:user, local: true, info: %{confirmation_pending: true})
1012 other_user = insert(:user, local: true)
1014 assert User.visible_for?(user, other_user)
1017 test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
1018 Pleroma.Config.put([:instance, :account_activation_required], true)
1020 user = insert(:user, local: true, info: %{confirmation_pending: true})
1021 other_user = insert(:user, local: true, info: %{is_admin: true})
1023 assert User.visible_for?(user, other_user)
1025 Pleroma.Config.put([:instance, :account_activation_required], false)
1029 describe "parse_bio/2" do
1030 test "preserves hosts in user links text" do
1031 remote_user = insert(:user, local: false, nickname: "nick@domain.com")
1032 user = insert(:user)
1033 bio = "A.k.a. @nick@domain.com"
1036 "A.k.a. <span class='h-card'><a data-user='#{remote_user.id}' class='u-url mention' href='#{
1038 }'>" <> "@<span>nick@domain.com</span></a></span>"
1040 assert expected_text == User.parse_bio(bio, user)
1045 user = insert(:user)
1048 CommonAPI.post(user, %{
1049 "status" => "heweoo!"
1052 id1 = activity1.data["object"]["id"]
1055 CommonAPI.post(user, %{
1056 "status" => "heweoo!"
1059 id2 = activity2.data["object"]["id"]
1061 assert {:ok, user_state1} = User.bookmark(user, id1)
1062 assert user_state1.bookmarks == [id1]
1064 assert {:ok, user_state2} = User.unbookmark(user, id1)
1065 assert user_state2.bookmarks == []
1067 assert {:ok, user_state3} = User.bookmark(user, id2)
1068 assert user_state3.bookmarks == [id2]