1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.UserSearchTest do
10 import Pleroma.Factory
13 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
17 describe "User.search" do
18 setup do: clear_config([:instance, :limit_to_local_content])
20 test "excludes invisible users from results" do
21 user = insert(:user, %{nickname: "john t1000"})
22 insert(:user, %{invisible: true, nickname: "john t800"})
24 [found_user] = User.search("john")
25 assert found_user.id == user.id
28 test "excludes service actors from results" do
29 insert(:user, actor_type: "Application", nickname: "user1")
30 service = insert(:user, actor_type: "Service", nickname: "user2")
31 person = insert(:user, actor_type: "Person", nickname: "user3")
33 assert [found_user1, found_user2] = User.search("user")
34 assert [found_user1.id, found_user2.id] -- [service.id, person.id] == []
37 test "accepts limit parameter" do
38 Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
39 assert length(User.search("john", limit: 3)) == 3
40 assert length(User.search("john")) == 5
43 test "accepts offset parameter" do
44 Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
45 assert length(User.search("john", limit: 3)) == 3
46 assert length(User.search("john", limit: 3, offset: 3)) == 2
49 test "finds a user by full or partial nickname" do
50 user = insert(:user, %{nickname: "john"})
52 Enum.each(["john", "jo", "j"], fn query ->
56 |> Map.put(:search_rank, nil)
57 |> Map.put(:search_type, nil)
61 test "finds a user by full or partial name" do
62 user = insert(:user, %{name: "John Doe"})
64 Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
68 |> Map.put(:search_rank, nil)
69 |> Map.put(:search_type, nil)
73 test "finds users, considering density of matched tokens" do
74 u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
75 u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})
77 assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
80 test "finds users, boosting ranks of friends and followers" do
82 u2 = insert(:user, %{name: "Doe"})
83 follower = insert(:user, %{name: "Doe"})
84 friend = insert(:user, %{name: "Doe"})
86 {:ok, follower} = User.follow(follower, u1)
87 {:ok, u1} = User.follow(u1, friend)
89 assert [friend.id, follower.id, u2.id] --
90 Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
93 test "finds followers of user by partial name" do
95 u2 = insert(:user, %{name: "Jimi"})
96 follower_jimi = insert(:user, %{name: "Jimi Hendrix"})
97 follower_lizz = insert(:user, %{name: "Lizz Wright"})
98 friend = insert(:user, %{name: "Jimi"})
100 {:ok, follower_jimi} = User.follow(follower_jimi, u1)
101 {:ok, _follower_lizz} = User.follow(follower_lizz, u2)
102 {:ok, u1} = User.follow(u1, friend)
104 assert Enum.map(User.search("jimi", following: true, for_user: u1), & &1.id) == [
108 assert User.search("lizz", following: true, for_user: u1) == []
111 test "find local and remote users for authenticated users" do
112 u1 = insert(:user, %{name: "lain"})
113 u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
114 u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
118 |> User.search(for_user: u1)
122 assert [u1.id, u2.id, u3.id] == results
125 test "find only local users for unauthenticated users" do
126 %{id: id} = insert(:user, %{name: "lain"})
127 insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
128 insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
130 assert [%{id: ^id}] = User.search("lain")
133 test "find only local users for authenticated users when `limit_to_local_content` is `:all`" do
134 Pleroma.Config.put([:instance, :limit_to_local_content], :all)
136 %{id: id} = insert(:user, %{name: "lain"})
137 insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
138 insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
140 assert [%{id: ^id}] = User.search("lain")
143 test "find all users for unauthenticated users when `limit_to_local_content` is `false`" do
144 Pleroma.Config.put([:instance, :limit_to_local_content], false)
146 u1 = insert(:user, %{name: "lain"})
147 u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
148 u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
156 assert [u1.id, u2.id, u3.id] == results
159 test "does not yield false-positive matches" do
160 insert(:user, %{name: "John Doe"})
162 Enum.each(["mary", "a", ""], fn query ->
163 assert [] == User.search(query)
167 test "works with URIs" do
171 User.search("http://mastodon.example.org/users/admin", resolve: true, for_user: user)
173 result = results |> List.first()
175 user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")
177 assert length(results) == 1
181 |> Map.put(:search_rank, nil)
182 |> Map.put(:search_type, nil)
183 |> Map.put(:last_digest_emailed_at, nil)
184 |> Map.put(:multi_factor_authentication_settings, nil)
185 |> Map.put(:notification_settings, nil)
187 assert user == expected
190 test "excludes a blocked users from search result" do
191 user = insert(:user, %{nickname: "Bill"})
193 [blocked_user | users] = Enum.map(0..3, &insert(:user, %{nickname: "john#{&1}"}))
198 %{nickname: "john awful", ap_id: "https://awful-and-rude-instance.com/user/bully"}
201 User.block_domain(user, "awful-and-rude-instance.com")
202 User.block(user, blocked_user)
204 account_ids = User.search("john", for_user: refresh_record(user)) |> collect_ids
206 assert account_ids == collect_ids(users)
207 refute Enum.member?(account_ids, blocked_user.id)
208 refute Enum.member?(account_ids, blocked_user2.id)
209 assert length(account_ids) == 3
212 test "local user has the same search_rank as for users with the same nickname, but another domain" do
214 insert(:user, nickname: "lain@mastodon.social")
215 insert(:user, nickname: "lain")
216 insert(:user, nickname: "lain@pleroma.social")
218 assert User.search("lain@localhost", resolve: true, for_user: user)
219 |> Enum.each(fn u -> u.search_rank == 0.5 end)
222 test "localhost is the part of the domain" do
224 insert(:user, nickname: "another@somedomain")
225 insert(:user, nickname: "lain")
226 insert(:user, nickname: "lain@examplelocalhost")
228 result = User.search("lain@examplelocalhost", resolve: true, for_user: user)
229 assert Enum.each(result, fn u -> u.search_rank == 0.5 end)
230 assert length(result) == 2
233 test "local user search with users" do
235 local_user = insert(:user, nickname: "lain")
236 insert(:user, nickname: "another@localhost.com")
237 insert(:user, nickname: "localhost@localhost.com")
239 [result] = User.search("lain@localhost", resolve: true, for_user: user)
240 assert Map.put(result, :search_rank, nil) |> Map.put(:search_type, nil) == local_user
243 test "works with idna domains" do
244 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
246 results = User.search("lain@zetsubou.みんな", resolve: false, for_user: user)
248 result = List.first(results)
250 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
253 test "works with idna domains converted input" do
254 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
257 User.search("lain@zetsubou." <> to_string(:idna.encode("zetsubou.みんな")),
262 result = List.first(results)
264 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
267 test "works with idna domains and bad chars in domain" do
268 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
271 User.search("lain@zetsubou!@#$%^&*()+,-/:;<=>?[]'_{}|~`.みんな",
276 result = List.first(results)
278 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
281 test "works with idna domains and query as link" do
282 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
285 User.search("https://zetsubou.みんな/users/lain",
290 result = List.first(results)
292 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)