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 "returns a resolved user as the first result" do
21 Pleroma.Config.put([:instance, :limit_to_local_content], false)
22 user = insert(:user, %{nickname: "no_relation", ap_id: "https://lain.com/users/lain"})
23 _user = insert(:user, %{nickname: "com_user"})
25 [first_user, _second_user] = User.search("https://lain.com/users/lain", resolve: true)
27 assert first_user.id == user.id
30 test "returns a user with matching ap_id as the first result" do
31 user = insert(:user, %{nickname: "no_relation", ap_id: "https://lain.com/users/lain"})
32 _user = insert(:user, %{nickname: "com_user"})
34 [first_user, _second_user] = User.search("https://lain.com/users/lain")
36 assert first_user.id == user.id
39 test "excludes invisible users from results" do
40 user = insert(:user, %{nickname: "john t1000"})
41 insert(:user, %{invisible: true, nickname: "john t800"})
43 [found_user] = User.search("john")
44 assert found_user.id == user.id
47 test "excludes users when discoverable is false" do
48 insert(:user, %{nickname: "john 3000", discoverable: false})
49 insert(:user, %{nickname: "john 3001"})
51 users = User.search("john")
52 assert Enum.count(users) == 1
55 test "excludes service actors from results" do
56 insert(:user, actor_type: "Application", nickname: "user1")
57 service = insert(:user, actor_type: "Service", nickname: "user2")
58 person = insert(:user, actor_type: "Person", nickname: "user3")
60 assert [found_user1, found_user2] = User.search("user")
61 assert [found_user1.id, found_user2.id] -- [service.id, person.id] == []
64 test "accepts limit parameter" do
65 Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
66 assert length(User.search("john", limit: 3)) == 3
67 assert length(User.search("john")) == 5
70 test "accepts offset parameter" do
71 Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
72 assert length(User.search("john", limit: 3)) == 3
73 assert length(User.search("john", limit: 3, offset: 3)) == 2
76 defp clear_virtual_fields(user) do
77 Map.merge(user, %{search_rank: nil, search_type: nil})
80 test "finds a user by full nickname or its leading fragment" do
81 user = insert(:user, %{nickname: "john"})
83 Enum.each(["john", "jo", "j"], fn query ->
87 |> clear_virtual_fields()
91 test "finds a user by full name or leading fragment(s) of its words" do
92 user = insert(:user, %{name: "John Doe"})
94 Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
98 |> clear_virtual_fields()
102 test "matches by leading fragment of user domain" do
103 user = insert(:user, %{nickname: "arandom@dude.com"})
104 insert(:user, %{nickname: "iamthedude"})
106 assert [user.id] == User.search("dud") |> Enum.map(& &1.id)
109 test "ranks full nickname match higher than full name match" do
110 nicknamed_user = insert(:user, %{nickname: "hj@shigusegubu.club"})
111 named_user = insert(:user, %{nickname: "xyz@sample.com", name: "HJ"})
113 results = User.search("hj")
115 assert [nicknamed_user.id, named_user.id] == Enum.map(results, & &1.id)
116 assert Enum.at(results, 0).search_rank > Enum.at(results, 1).search_rank
119 test "finds users, considering density of matched tokens" do
120 u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
121 u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})
123 assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
126 test "finds users, boosting ranks of friends and followers" do
128 u2 = insert(:user, %{name: "Doe"})
129 follower = insert(:user, %{name: "Doe"})
130 friend = insert(:user, %{name: "Doe"})
132 {:ok, follower} = User.follow(follower, u1)
133 {:ok, u1} = User.follow(u1, friend)
135 assert [friend.id, follower.id, u2.id] --
136 Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
139 test "finds followings of user by partial name" do
140 lizz = insert(:user, %{name: "Lizz"})
141 jimi = insert(:user, %{name: "Jimi"})
142 following_lizz = insert(:user, %{name: "Jimi Hendrix"})
143 following_jimi = insert(:user, %{name: "Lizz Wright"})
144 follower_lizz = insert(:user, %{name: "Jimi"})
146 {:ok, lizz} = User.follow(lizz, following_lizz)
147 {:ok, _jimi} = User.follow(jimi, following_jimi)
148 {:ok, _follower_lizz} = User.follow(follower_lizz, lizz)
150 assert Enum.map(User.search("jimi", following: true, for_user: lizz), & &1.id) == [
154 assert User.search("lizz", following: true, for_user: lizz) == []
157 test "find local and remote users for authenticated users" do
158 u1 = insert(:user, %{name: "lain"})
159 u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
160 u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
164 |> User.search(for_user: u1)
168 assert [u1.id, u2.id, u3.id] == results
171 test "find only local users for unauthenticated users" do
172 %{id: id} = insert(:user, %{name: "lain"})
173 insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
174 insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
176 assert [%{id: ^id}] = User.search("lain")
179 test "find only local users for authenticated users when `limit_to_local_content` is `:all`" do
180 Pleroma.Config.put([:instance, :limit_to_local_content], :all)
182 %{id: id} = insert(:user, %{name: "lain"})
183 insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
184 insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
186 assert [%{id: ^id}] = User.search("lain")
189 test "find all users for unauthenticated users when `limit_to_local_content` is `false`" do
190 Pleroma.Config.put([:instance, :limit_to_local_content], false)
192 u1 = insert(:user, %{name: "lain"})
193 u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
194 u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
202 assert [u1.id, u2.id, u3.id] == results
205 test "does not yield false-positive matches" do
206 insert(:user, %{name: "John Doe"})
208 Enum.each(["mary", "a", ""], fn query ->
209 assert [] == User.search(query)
213 test "works with URIs" do
217 User.search("http://mastodon.example.org/users/admin", resolve: true, for_user: user)
219 result = results |> List.first()
221 user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")
223 assert length(results) == 1
227 |> Map.put(:search_rank, nil)
228 |> Map.put(:search_type, nil)
229 |> Map.put(:last_digest_emailed_at, nil)
230 |> Map.put(:multi_factor_authentication_settings, nil)
231 |> Map.put(:notification_settings, nil)
233 assert user == expected
236 test "excludes a blocked users from search result" do
237 user = insert(:user, %{nickname: "Bill"})
239 [blocked_user | users] = Enum.map(0..3, &insert(:user, %{nickname: "john#{&1}"}))
244 %{nickname: "john awful", ap_id: "https://awful-and-rude-instance.com/user/bully"}
247 User.block_domain(user, "awful-and-rude-instance.com")
248 User.block(user, blocked_user)
250 account_ids = User.search("john", for_user: refresh_record(user)) |> collect_ids
252 assert account_ids == collect_ids(users)
253 refute Enum.member?(account_ids, blocked_user.id)
254 refute Enum.member?(account_ids, blocked_user2.id)
255 assert length(account_ids) == 3
258 test "local user has the same search_rank as for users with the same nickname, but another domain" do
260 insert(:user, nickname: "lain@mastodon.social")
261 insert(:user, nickname: "lain")
262 insert(:user, nickname: "lain@pleroma.social")
264 assert User.search("lain@localhost", resolve: true, for_user: user)
265 |> Enum.each(fn u -> u.search_rank == 0.5 end)
268 test "localhost is the part of the domain" do
270 insert(:user, nickname: "another@somedomain")
271 insert(:user, nickname: "lain")
272 insert(:user, nickname: "lain@examplelocalhost")
274 result = User.search("lain@examplelocalhost", resolve: true, for_user: user)
275 assert Enum.each(result, fn u -> u.search_rank == 0.5 end)
276 assert length(result) == 2
279 test "local user search with users" do
281 local_user = insert(:user, nickname: "lain")
282 insert(:user, nickname: "another@localhost.com")
283 insert(:user, nickname: "localhost@localhost.com")
285 [result] = User.search("lain@localhost", resolve: true, for_user: user)
286 assert Map.put(result, :search_rank, nil) |> Map.put(:search_type, nil) == local_user
289 test "works with idna domains" do
290 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
292 results = User.search("lain@zetsubou.みんな", resolve: false, for_user: user)
294 result = List.first(results)
296 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
299 test "works with idna domains converted input" do
300 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
303 User.search("lain@zetsubou." <> to_string(:idna.encode("zetsubou.みんな")),
308 result = List.first(results)
310 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
313 test "works with idna domains and bad chars in domain" do
314 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
317 User.search("lain@zetsubou!@#$%^&*()+,-/:;<=>?[]'_{}|~`.みんな",
322 result = List.first(results)
324 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
327 test "works with idna domains and query as link" do
328 user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
331 User.search("https://zetsubou.みんな/users/lain",
336 result = List.first(results)
338 assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)