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