Add ability to search on Group, Person or Event

Signed-off-by: Thomas Citharel <tcit@tcit.fr>
2019-04-12 15:04:32 +02:00
parent 20a4f7244c
commit d66bbc5414
10 changed files with 385 additions and 173 deletions
--- a/test/mobilizon/actors/actors_test.exs
+++ b/test/mobilizon/actors/actors_test.exs
@@ -184,19 +184,26 @@ defmodule Mobilizon.ActorsTest do
      assert MapSet.new([actor_found_id, actor2_found_id]) == MapSet.new([actor.id, actor2.id])
    end

-    test "test find_actors_by_username_or_name/1 returns actors with similar usernames", %{
-      actor: %Actor{id: actor_id}
-    } do
+    test "test find_and_count_actors_by_username_or_name/4 returns actors with similar usernames",
+         %{
+           actor: %Actor{id: actor_id}
+         } do
      use_cassette "actors/remote_actor_mastodon_tcit" do
        with {:ok, %Actor{id: actor2_id}} <- Actors.get_or_fetch_by_url(@remote_account_url) do
-          actors_ids = Actors.find_actors_by_username_or_name("tcit") |> Enum.map(& &1.id)
+          %{total: 2, elements: actors} =
+            Actors.find_and_count_actors_by_username_or_name("tcit", [:Person])
+
+          actors_ids = actors |> Enum.map(& &1.id)
+
          assert MapSet.new(actors_ids) == MapSet.new([actor2_id, actor_id])
        end
      end
    end

-    test "test find_actors_by_username_or_name/1 returns actors with similar names" do
-      actors = Actors.find_actors_by_username_or_name("ohno")
+    test "test find_and_count_actors_by_username_or_name/4 returns actors with similar names" do
+      %{total: 0, elements: actors} =
+        Actors.find_and_count_actors_by_username_or_name("ohno", [:Person])
+
      assert actors == []
    end

--- a/test/mobilizon/events/events_test.exs
+++ b/test/mobilizon/events/events_test.exs
@@ -54,18 +54,22 @@ defmodule Mobilizon.EventsTest do
      assert Events.get_event_full!(event.id).participants == []
    end

-    test "find_events_by_name/1 returns events for a given name", %{
+    test "find_and_count_events_by_name/1 returns events for a given name", %{
      event: %Event{title: title} = event
    } do
-      assert title == hd(Events.find_events_by_name(event.title)).title
+      assert title == hd(Events.find_and_count_events_by_name(event.title).elements).title

-      %Event{title: title2} = event2 = insert(:event, title: "Special event")
-      assert event2.title == Events.find_events_by_name("Special") |> hd() |> Map.get(:title)
+      %Event{} = event2 = insert(:event, title: "Special event")

-      assert event2.title == Events.find_events_by_name("  Special  ") |> hd() |> Map.get(:title)
+      assert event2.title ==
+               Events.find_and_count_events_by_name("Special").elements |> hd() |> Map.get(:title)

-      assert title == Events.find_events_by_name("") |> hd() |> Map.get(:title)
-      assert title2 == Events.find_events_by_name("") |> tl |> hd() |> Map.get(:title)
+      assert event2.title ==
+               Events.find_and_count_events_by_name("  Special  ").elements
+               |> hd()
+               |> Map.get(:title)
+
+      assert %{elements: [], total: 0} == Events.find_and_count_events_by_name("")
    end

    test "find_close_events/3 returns events in the area" do
--- a/test/mobilizon_web/api/search_test.exs
+++ b/test/mobilizon_web/api/search_test.exs
@@ -12,44 +12,45 @@ defmodule MobilizonWeb.API.SearchTest do

  test "search an user by username" do
    with_mock ActivityPub,
-      find_or_make_actor_from_nickname: fn "toto@domain.tld" -> {:ok, %Actor{id: 1}} end do
-      assert {:ok, %Actor{id: 1}} == Search.search("toto@domain.tld")
+      find_or_make_actor_from_nickname: fn "toto@domain.tld" -> {:ok, %Actor{id: 42}} end do
+      assert {:ok, %{total: 1, elements: [%Actor{id: 42}]}} ==
+               Search.search_actors("toto@domain.tld", 1, 10, :Person)
+
      assert_called(ActivityPub.find_or_make_actor_from_nickname("toto@domain.tld"))
    end
  end

  test "search something by URL" do
    with_mock ActivityPub,
-      fetch_object_from_url: fn "https://social.tcit.fr/users/tcit" -> {:ok, %Actor{id: 1}} end do
-      assert {:ok, %Actor{id: 1}} == Search.search("https://social.tcit.fr/users/tcit")
-      assert_called(ActivityPub.fetch_object_from_url("https://social.tcit.fr/users/tcit"))
-    end
-  end
+      fetch_object_from_url: fn "https://social.tcit.fr/users/tcit" -> {:ok, %Actor{id: 42}} end do
+      assert {:ok, %{total: 1, elements: [%Actor{id: 42}]}} ==
+               Search.search_actors("https://social.tcit.fr/users/tcit", 1, 10, :Person)

-  test "search everything" do
-    with_mocks([
-      {Actors, [], [find_actors_by_username_or_name: fn "toto", 1, 10 -> [%Actor{}] end]},
-      {Events, [], [find_events_by_name: fn "toto", 1, 10 -> [%Event{}] end]}
-    ]) do
-      assert {:ok, [%Event{}, %Actor{}]} = Search.search("toto")
-      assert_called(Actors.find_actors_by_username_or_name("toto", 1, 10))
-      assert_called(Events.find_events_by_name("toto", 1, 10))
+      assert_called(ActivityPub.fetch_object_from_url("https://social.tcit.fr/users/tcit"))
    end
  end

  test "search actors" do
    with_mock Actors,
-      find_actors_by_username_or_name: fn "toto", 1, 10 -> [%Actor{}] end do
-      assert {:ok, [%Actor{}]} = Search.search_actors("toto")
-      assert_called(Actors.find_actors_by_username_or_name("toto", 1, 10))
+      find_and_count_actors_by_username_or_name: fn "toto", _type, 1, 10 ->
+        %{total: 1, elements: [%Actor{id: 42}]}
+      end do
+      assert {:ok, %{total: 1, elements: [%Actor{id: 42}]}} =
+               Search.search_actors("toto", 1, 10, :Person)
+
+      assert_called(Actors.find_and_count_actors_by_username_or_name("toto", [:Person], 1, 10))
    end
  end

  test "search events" do
    with_mock Events,
-      find_events_by_name: fn "toto", 1, 10 -> [%Event{}] end do
-      assert {:ok, [%Event{}]} = Search.search_events("toto")
-      assert_called(Events.find_events_by_name("toto", 1, 10))
+      find_and_count_events_by_name: fn "toto", 1, 10 ->
+        %{total: 1, elements: [%Event{title: "super toto event"}]}
+      end do
+      assert {:ok, %{total: 1, elements: [%Event{title: "super toto event"}]}} =
+               Search.search_events("toto", 1, 10)
+
+      assert_called(Events.find_and_count_events_by_name("toto", 1, 10))
    end
  end
 end
--- a/test/mobilizon_web/resolvers/search_resolver_test.exs
+++ b/test/mobilizon_web/resolvers/search_resolver_test.exs
@@ -9,26 +9,24 @@ defmodule MobilizonWeb.Resolvers.SearchResolverTest do
    {:ok, conn: conn, user: user}
  end

-  test "search_events_and_actors/3 finds events and actors with basic search", %{
+  test "search_events/3 finds events with basic search", %{
    conn: conn,
    user: user
  } do
-    actor = insert(:actor, user: user, preferred_username: "test")
-    event = insert(:event, title: "test")
+    insert(:actor, user: user, preferred_username: "test_person")
+    insert(:actor, type: :Group, preferred_username: "test_group")
+    event = insert(:event, title: "test_event")

    query = """
    {
-        search(search: "test") {
-            ...on Event {
+        search_events(search: "test") {
+            total,
+            elements {
              title,
              uuid,
              __typename
-            },
-            ...on Actor {
-              preferredUsername,
-              __typename
            }
-          }
+        },
    }
    """

@@ -36,33 +34,172 @@ defmodule MobilizonWeb.Resolvers.SearchResolverTest do
      conn
      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))

-    assert hd(json_response(res, 200)["data"]["search"])["uuid"] == to_string(event.uuid)
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_events"]["total"] == 1
+    assert json_response(res, 200)["data"]["search_events"]["elements"] |> length == 1

-    assert hd(tl(json_response(res, 200)["data"]["search"]))["preferredUsername"] ==
-             actor.preferred_username
+    assert hd(json_response(res, 200)["data"]["search_events"]["elements"])["uuid"] ==
+             to_string(event.uuid)
  end

-  test "search_events_and_actors/3 finds events and actors with word search", %{
+  test "search_persons/3 finds persons with basic search", %{
    conn: conn,
    user: user
  } do
-    actor = insert(:actor, user: user, preferred_username: "toto", name: "I like pineapples")
-    event = insert(:event, title: "Pineapple fashion week")
+    actor = insert(:actor, user: user, preferred_username: "test_person")
+    insert(:actor, type: :Group, preferred_username: "test_group")
+    insert(:event, title: "test_event")
+
+    query = """
+    {
+        search_persons(search: "test") {
+          total,
+          elements {
+            preferredUsername,
+            __typename
+          }
+        },
+    }
+    """
+
+    res =
+      conn
+      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))
+
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_persons"]["total"] == 1
+    assert json_response(res, 200)["data"]["search_persons"]["elements"] |> length == 1
+
+    assert hd(json_response(res, 200)["data"]["search_persons"]["elements"])["preferredUsername"] ==
+             actor.preferred_username
+  end
+
+  test "search_groups/3 finds persons with basic search", %{
+    conn: conn,
+    user: user
+  } do
+    insert(:actor, user: user, preferred_username: "test_person")
+    group = insert(:actor, type: :Group, preferred_username: "test_group")
+    insert(:event, title: "test_event")
+
+    query = """
+    {
+        search_groups(search: "test") {
+          total,
+          elements {
+            preferredUsername,
+            __typename
+          }
+        },
+    }
+    """
+
+    res =
+      conn
+      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))
+
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_groups"]["total"] == 1
+    assert json_response(res, 200)["data"]["search_groups"]["elements"] |> length == 1
+
+    assert hd(json_response(res, 200)["data"]["search_groups"]["elements"])["preferredUsername"] ==
+             group.preferred_username
+  end
+
+  test "search_events/3 finds events and actors with word search", %{
+    conn: conn,
+    user: user
+  } do
+    insert(:actor, user: user, preferred_username: "person", name: "I like pineapples")
+    insert(:event, title: "Pineapple fashion week")
+    insert(:event, title: "I love pineAPPLE")
+    insert(:event, title: "Hello")
+
+    query = """
+    {
+        search_events(search: "pineapple") {
+          total,
+          elements {
+            title,
+            uuid,
+            __typename
+          }
+        }
+    }
+    """
+
+    res =
+      conn
+      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))
+
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_events"]["total"] == 2
+
+    assert json_response(res, 200)["data"]["search_events"]["elements"]
+           |> length == 2
+
+    assert json_response(res, 200)["data"]["search_events"]["elements"]
+           |> Enum.map(& &1["title"]) == [
+             "I love pineAPPLE",
+             "Pineapple fashion week"
+           ]
+  end
+
+  test "search_persons/3 finds persons with word search", %{
+    conn: conn,
+    user: user
+  } do
+    actor = insert(:actor, user: user, preferred_username: "person", name: "I like pineapples")
+    insert(:actor, preferred_username: "group", type: :Group, name: "pineapple group")
+    insert(:event, title: "Pineapple fashion week")
+    insert(:event, title: "I love pineAPPLE")
+    insert(:event, title: "Hello")
+
+    query = """
+    {
+        search_persons(search: "pineapple") {
+          total,
+          elements {
+            preferredUsername,
+            __typename
+          }
+        }
+    }
+    """
+
+    res =
+      conn
+      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))
+
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_persons"]["total"] == 1
+
+    assert json_response(res, 200)["data"]["search_persons"]["elements"]
+           |> length == 1
+
+    assert hd(json_response(res, 200)["data"]["search_persons"]["elements"])["preferredUsername"] ==
+             actor.preferred_username
+  end
+
+  test "search_events/3 finds events with accented search", %{
+    conn: conn,
+    user: user
+  } do
+    insert(:actor, user: user, preferred_username: "person", name: "Torréfaction du Kafé")
+    insert(:actor, type: :Group, preferred_username: "group", name: "Kafé group")
+    event = insert(:event, title: "Tour du monde des Kafés")

    # Elaborate query
    query = """
    {
-        search(search: "pineapple") {
-            ...on Event {
-              title,
-              uuid,
-              __typename
-            },
-            ...on Actor {
-              preferredUsername,
-              __typename
-            }
+        search_events(search: "Kafé") {
+          total,
+          elements {
+            title,
+            uuid,
+            __typename
          }
+        }
    }
    """

@@ -70,33 +207,29 @@ defmodule MobilizonWeb.Resolvers.SearchResolverTest do
      conn
      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))

-    assert hd(json_response(res, 200)["data"]["search"])["uuid"] == to_string(event.uuid)
-
-    assert hd(tl(json_response(res, 200)["data"]["search"]))["preferredUsername"] ==
-             actor.preferred_username
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_events"]["total"] == 1
+    assert hd(json_response(res, 200)["data"]["search_events"]["elements"])["uuid"] == event.uuid
  end

-  test "search_events_and_actors/3 finds events and actors with accented search", %{
+  test "search_groups/3 finds groups with accented search", %{
    conn: conn,
    user: user
  } do
-    insert(:actor, user: user, preferred_username: "toto", name: "Torréfaction")
-    event = insert(:event, title: "Tour du monde des cafés")
+    insert(:actor, user: user, preferred_username: "person", name: "Torréfaction du Kafé")
+    group = insert(:actor, type: :Group, preferred_username: "group", name: "Kafé group")
+    insert(:event, title: "Tour du monde des Kafés")

    # Elaborate query
    query = """
    {
-        search(search: "café") {
-            ...on Event {
-              title,
-              uuid,
-              __typename
-            },
-            ...on Actor {
-              preferredUsername,
-              __typename
-            }
+        search_groups(search: "Kafé") {
+          total,
+          elements {
+            preferredUsername,
+            __typename
          }
+        }
    }
    """

@@ -104,6 +237,10 @@ defmodule MobilizonWeb.Resolvers.SearchResolverTest do
      conn
      |> get("/api", AbsintheHelpers.query_skeleton(query, "search"))

-    assert hd(json_response(res, 200)["data"]["search"])["uuid"] == to_string(event.uuid)
+    assert json_response(res, 200)["errors"] == nil
+    assert json_response(res, 200)["data"]["search_groups"]["total"] == 1
+
+    assert hd(json_response(res, 200)["data"]["search_groups"]["elements"])["preferredUsername"] ==
+             group.preferred_username
  end
 end