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

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