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