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