Merge branch 'develop' into feature/bulk-confirmation

[akkoma] / test / user_search_test.exs

diff --git a/test/user_search_test.exs b/test/user_search_test.exs
index f030523d3a9ac178fa7cda4d0df7980f873d160f..8529ce6dbf324e921a05b7b26b8f5e53ca26b4c0 100644 (file)
--- a/test/user_search_test.exs
+++ b/test/user_search_test.exs
@@ -25,6 +25,14 @@ defmodule Pleroma.UserSearchTest do
       assert found_user.id == user.id
     end
 
+    test "excludes users when discoverable is false" do
+      insert(:user, %{nickname: "john 3000", discoverable: false})
+      insert(:user, %{nickname: "john 3001"})
+
+      users = User.search("john")
+      assert Enum.count(users) == 1
+    end
+
     test "excludes service actors from results" do
       insert(:user, actor_type: "Application", nickname: "user1")
       service = insert(:user, actor_type: "Service", nickname: "user2")
@@ -46,30 +54,49 @@ defmodule Pleroma.UserSearchTest do
       assert length(User.search("john", limit: 3, offset: 3)) == 2
     end
 
-    test "finds a user by full or partial nickname" do
+    defp clear_virtual_fields(user) do
+      Map.merge(user, %{search_rank: nil, search_type: nil})
+    end
+
+    test "finds a user by full nickname or its leading fragment" do
       user = insert(:user, %{nickname: "john"})
 
       Enum.each(["john", "jo", "j"], fn query ->
         assert user ==
                  User.search(query)
                  |> List.first()
-                 |> Map.put(:search_rank, nil)
-                 |> Map.put(:search_type, nil)
+                 |> clear_virtual_fields()
       end)
     end
 
-    test "finds a user by full or partial name" do
+    test "finds a user by full name or leading fragment(s) of its words" do
       user = insert(:user, %{name: "John Doe"})
 
       Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
         assert user ==
                  User.search(query)
                  |> List.first()
-                 |> Map.put(:search_rank, nil)
-                 |> Map.put(:search_type, nil)
+                 |> clear_virtual_fields()
       end)
     end
 
+    test "matches by leading fragment of user domain" do
+      user = insert(:user, %{nickname: "arandom@dude.com"})
+      insert(:user, %{nickname: "iamthedude"})
+
+      assert [user.id] == User.search("dud") |> Enum.map(& &1.id)
+    end
+
+    test "ranks full nickname match higher than full name match" do
+      nicknamed_user = insert(:user, %{nickname: "hj@shigusegubu.club"})
+      named_user = insert(:user, %{nickname: "xyz@sample.com", name: "HJ"})
+
+      results = User.search("hj")
+
+      assert [nicknamed_user.id, named_user.id] == Enum.map(results, & &1.id)
+      assert Enum.at(results, 0).search_rank > Enum.at(results, 1).search_rank
+    end
+
     test "finds users, considering density of matched tokens" do
       u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
       u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})
@@ -90,22 +117,22 @@ defmodule Pleroma.UserSearchTest do
                Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
     end
 
-    test "finds followers of user by partial name" do
-      u1 = insert(:user)
-      u2 = insert(:user, %{name: "Jimi"})
-      follower_jimi = insert(:user, %{name: "Jimi Hendrix"})
-      follower_lizz = insert(:user, %{name: "Lizz Wright"})
-      friend = insert(:user, %{name: "Jimi"})
+    test "finds followings of user by partial name" do
+      lizz = insert(:user, %{name: "Lizz"})
+      jimi = insert(:user, %{name: "Jimi"})
+      following_lizz = insert(:user, %{name: "Jimi Hendrix"})
+      following_jimi = insert(:user, %{name: "Lizz Wright"})
+      follower_lizz = insert(:user, %{name: "Jimi"})
 
-      {:ok, follower_jimi} = User.follow(follower_jimi, u1)
-      {:ok, _follower_lizz} = User.follow(follower_lizz, u2)
-      {:ok, u1} = User.follow(u1, friend)
+      {:ok, lizz} = User.follow(lizz, following_lizz)
+      {:ok, _jimi} = User.follow(jimi, following_jimi)
+      {:ok, _follower_lizz} = User.follow(follower_lizz, lizz)
 
-      assert Enum.map(User.search("jimi", following: true, for_user: u1), & &1.id) == [
-               follower_jimi.id
+      assert Enum.map(User.search("jimi", following: true, for_user: lizz), & &1.id) == [
+               following_lizz.id
              ]
 
-      assert User.search("lizz", following: true, for_user: u1) == []
+      assert User.search("lizz", following: true, for_user: lizz) == []
     end
 
     test "find local and remote users for authenticated users" do