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