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

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