git.squeep.com Git - akkoma/blob - test/user_search_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.UserSearchTest do
   6   alias Pleroma.Repo
   7   alias Pleroma.User
   8   use Pleroma.DataCase
   9
  10   import Pleroma.Factory
  11
  12   setup_all do
  13     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  14     :ok
  15   end
  16
  17   describe "User.search" do
  18     setup do: clear_config([:instance, :limit_to_local_content])
  19
  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"})
  24
  25       [first_user, _second_user] = User.search("https://lain.com/users/lain", resolve: true)
  26
  27       assert first_user.id == user.id
  28     end
  29
  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"})
  33
  34       [first_user, _second_user] = User.search("https://lain.com/users/lain")
  35
  36       assert first_user.id == user.id
  37     end
  38
  39     test "returns a user with matching uri as the first result" do
  40       user =
  41         insert(:user, %{
  42           nickname: "no_relation",
  43           ap_id: "https://lain.com/users/lain",
  44           uri: "https://lain.com/@Lain"
  45         })
  46
  47       _user = insert(:user, %{nickname: "com_user"})
  48
  49       [first_user, _second_user] = User.search("https://lain.com/@lain")
  50
  51       assert first_user.id == user.id
  52     end
  53
  54     test "excludes invisible users from results" do
  55       user = insert(:user, %{nickname: "john t1000"})
  56       insert(:user, %{invisible: true, nickname: "john t800"})
  57
  58       [found_user] = User.search("john")
  59       assert found_user.id == user.id
  60     end
  61
  62     test "excludes users when discoverable is false" do
  63       insert(:user, %{nickname: "john 3000", discoverable: false})
  64       insert(:user, %{nickname: "john 3001"})
  65
  66       users = User.search("john")
  67       assert Enum.count(users) == 1
  68     end
  69
  70     test "excludes service actors from results" do
  71       insert(:user, actor_type: "Application", nickname: "user1")
  72       service = insert(:user, actor_type: "Service", nickname: "user2")
  73       person = insert(:user, actor_type: "Person", nickname: "user3")
  74
  75       assert [found_user1, found_user2] = User.search("user")
  76       assert [found_user1.id, found_user2.id] -- [service.id, person.id] == []
  77     end
  78
  79     test "accepts limit parameter" do
  80       Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
  81       assert length(User.search("john", limit: 3)) == 3
  82       assert length(User.search("john")) == 5
  83     end
  84
  85     test "accepts offset parameter" do
  86       Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
  87       assert length(User.search("john", limit: 3)) == 3
  88       assert length(User.search("john", limit: 3, offset: 3)) == 2
  89     end
  90
  91     defp clear_virtual_fields(user) do
  92       Map.merge(user, %{search_rank: nil, search_type: nil})
  93     end
  94
  95     test "finds a user by full nickname or its leading fragment" do
  96       user = insert(:user, %{nickname: "john"})
  97
  98       Enum.each(["john", "jo", "j"], fn query ->
  99         assert user ==
 100                  User.search(query)
 101                  |> List.first()
 102                  |> clear_virtual_fields()
 103       end)
 104     end
 105
 106     test "finds a user by full name or leading fragment(s) of its words" do
 107       user = insert(:user, %{name: "John Doe"})
 108
 109       Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
 110         assert user ==
 111                  User.search(query)
 112                  |> List.first()
 113                  |> clear_virtual_fields()
 114       end)
 115     end
 116
 117     test "matches by leading fragment of user domain" do
 118       user = insert(:user, %{nickname: "arandom@dude.com"})
 119       insert(:user, %{nickname: "iamthedude"})
 120
 121       assert [user.id] == User.search("dud") |> Enum.map(& &1.id)
 122     end
 123
 124     test "ranks full nickname match higher than full name match" do
 125       nicknamed_user = insert(:user, %{nickname: "hj@shigusegubu.club"})
 126       named_user = insert(:user, %{nickname: "xyz@sample.com", name: "HJ"})
 127
 128       results = User.search("hj")
 129
 130       assert [nicknamed_user.id, named_user.id] == Enum.map(results, & &1.id)
 131       assert Enum.at(results, 0).search_rank > Enum.at(results, 1).search_rank
 132     end
 133
 134     test "finds users, considering density of matched tokens" do
 135       u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
 136       u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})
 137
 138       assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
 139     end
 140
 141     test "finds users, boosting ranks of friends and followers" do
 142       u1 = insert(:user)
 143       u2 = insert(:user, %{name: "Doe"})
 144       follower = insert(:user, %{name: "Doe"})
 145       friend = insert(:user, %{name: "Doe"})
 146
 147       {:ok, follower} = User.follow(follower, u1)
 148       {:ok, u1} = User.follow(u1, friend)
 149
 150       assert [friend.id, follower.id, u2.id] --
 151                Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
 152     end
 153
 154     test "finds followings of user by partial name" do
 155       lizz = insert(:user, %{name: "Lizz"})
 156       jimi = insert(:user, %{name: "Jimi"})
 157       following_lizz = insert(:user, %{name: "Jimi Hendrix"})
 158       following_jimi = insert(:user, %{name: "Lizz Wright"})
 159       follower_lizz = insert(:user, %{name: "Jimi"})
 160
 161       {:ok, lizz} = User.follow(lizz, following_lizz)
 162       {:ok, _jimi} = User.follow(jimi, following_jimi)
 163       {:ok, _follower_lizz} = User.follow(follower_lizz, lizz)
 164
 165       assert Enum.map(User.search("jimi", following: true, for_user: lizz), & &1.id) == [
 166                following_lizz.id
 167              ]
 168
 169       assert User.search("lizz", following: true, for_user: lizz) == []
 170     end
 171
 172     test "find local and remote users for authenticated users" do
 173       u1 = insert(:user, %{name: "lain"})
 174       u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
 175       u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
 176
 177       results =
 178         "lain"
 179         |> User.search(for_user: u1)
 180         |> Enum.map(& &1.id)
 181         |> Enum.sort()
 182
 183       assert [u1.id, u2.id, u3.id] == results
 184     end
 185
 186     test "find only local users for unauthenticated users" do
 187       %{id: id} = insert(:user, %{name: "lain"})
 188       insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
 189       insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
 190
 191       assert [%{id: ^id}] = User.search("lain")
 192     end
 193
 194     test "find only local users for authenticated users when `limit_to_local_content` is `:all`" do
 195       Pleroma.Config.put([:instance, :limit_to_local_content], :all)
 196
 197       %{id: id} = insert(:user, %{name: "lain"})
 198       insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
 199       insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
 200
 201       assert [%{id: ^id}] = User.search("lain")
 202     end
 203
 204     test "find all users for unauthenticated users when `limit_to_local_content` is `false`" do
 205       Pleroma.Config.put([:instance, :limit_to_local_content], false)
 206
 207       u1 = insert(:user, %{name: "lain"})
 208       u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
 209       u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})
 210
 211       results =
 212         "lain"
 213         |> User.search()
 214         |> Enum.map(& &1.id)
 215         |> Enum.sort()
 216
 217       assert [u1.id, u2.id, u3.id] == results
 218     end
 219
 220     test "does not yield false-positive matches" do
 221       insert(:user, %{name: "John Doe"})
 222
 223       Enum.each(["mary", "a", ""], fn query ->
 224         assert [] == User.search(query)
 225       end)
 226     end
 227
 228     test "works with URIs" do
 229       user = insert(:user)
 230
 231       results =
 232         User.search("http://mastodon.example.org/users/admin", resolve: true, for_user: user)
 233
 234       result = results |> List.first()
 235
 236       user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")
 237
 238       assert length(results) == 1
 239
 240       expected =
 241         result
 242         |> Map.put(:search_rank, nil)
 243         |> Map.put(:search_type, nil)
 244         |> Map.put(:last_digest_emailed_at, nil)
 245         |> Map.put(:multi_factor_authentication_settings, nil)
 246         |> Map.put(:notification_settings, nil)
 247
 248       assert user == expected
 249     end
 250
 251     test "excludes a blocked users from search result" do
 252       user = insert(:user, %{nickname: "Bill"})
 253
 254       [blocked_user | users] = Enum.map(0..3, &insert(:user, %{nickname: "john#{&1}"}))
 255
 256       blocked_user2 =
 257         insert(
 258           :user,
 259           %{nickname: "john awful", ap_id: "https://awful-and-rude-instance.com/user/bully"}
 260         )
 261
 262       User.block_domain(user, "awful-and-rude-instance.com")
 263       User.block(user, blocked_user)
 264
 265       account_ids = User.search("john", for_user: refresh_record(user)) |> collect_ids
 266
 267       assert account_ids == collect_ids(users)
 268       refute Enum.member?(account_ids, blocked_user.id)
 269       refute Enum.member?(account_ids, blocked_user2.id)
 270       assert length(account_ids) == 3
 271     end
 272
 273     test "local user has the same search_rank as for users with the same nickname, but another domain" do
 274       user = insert(:user)
 275       insert(:user, nickname: "lain@mastodon.social")
 276       insert(:user, nickname: "lain")
 277       insert(:user, nickname: "lain@pleroma.social")
 278
 279       assert User.search("lain@localhost", resolve: true, for_user: user)
 280              |> Enum.each(fn u -> u.search_rank == 0.5 end)
 281     end
 282
 283     test "localhost is the part of the domain" do
 284       user = insert(:user)
 285       insert(:user, nickname: "another@somedomain")
 286       insert(:user, nickname: "lain")
 287       insert(:user, nickname: "lain@examplelocalhost")
 288
 289       result = User.search("lain@examplelocalhost", resolve: true, for_user: user)
 290       assert Enum.each(result, fn u -> u.search_rank == 0.5 end)
 291       assert length(result) == 2
 292     end
 293
 294     test "local user search with users" do
 295       user = insert(:user)
 296       local_user = insert(:user, nickname: "lain")
 297       insert(:user, nickname: "another@localhost.com")
 298       insert(:user, nickname: "localhost@localhost.com")
 299
 300       [result] = User.search("lain@localhost", resolve: true, for_user: user)
 301       assert Map.put(result, :search_rank, nil) |> Map.put(:search_type, nil) == local_user
 302     end
 303
 304     test "works with idna domains" do
 305       user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
 306
 307       results = User.search("lain@zetsubou.みんな", resolve: false, for_user: user)
 308
 309       result = List.first(results)
 310
 311       assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
 312     end
 313
 314     test "works with idna domains converted input" do
 315       user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
 316
 317       results =
 318         User.search("lain@zetsubou." <> to_string(:idna.encode("zetsubou.みんな")),
 319           resolve: false,
 320           for_user: user
 321         )
 322
 323       result = List.first(results)
 324
 325       assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
 326     end
 327
 328     test "works with idna domains and bad chars in domain" do
 329       user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
 330
 331       results =
 332         User.search("lain@zetsubou!@#$%^&*()+,-/:;<=>?[]'_{}|~`.みんな",
 333           resolve: false,
 334           for_user: user
 335         )
 336
 337       result = List.first(results)
 338
 339       assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
 340     end
 341
 342     test "works with idna domains and query as link" do
 343       user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))
 344
 345       results =
 346         User.search("https://zetsubou.みんな/users/lain",
 347           resolve: false,
 348           for_user: user
 349         )
 350
 351       result = List.first(results)
 352
 353       assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)
 354     end
 355   end
 356 end