Git of dcc - anni/blob - test/pleroma/search/meilisearch_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Search.MeilisearchTest do
   6   require Pleroma.Constants
   7
   8   use Pleroma.DataCase, async: true
   9   use Oban.Testing, repo: Pleroma.Repo
  10
  11   import Pleroma.Factory
  12   import Tesla.Mock
  13   import Mox
  14
  15   alias Pleroma.Search.Meilisearch
  16   alias Pleroma.UnstubbedConfigMock, as: Config
  17   alias Pleroma.Web.CommonAPI
  18   alias Pleroma.Workers.SearchIndexingWorker
  19
  20   describe "meilisearch" do
  21     test "indexes a local post on creation" do
  22       user = insert(:user)
  23
  24       Tesla.Mock.mock(fn
  25         %{
  26           method: :put,
  27           url: "http://127.0.0.1:7700/indexes/objects/documents",
  28           body: body
  29         } ->
  30           assert match?(
  31                    [%{"content" => "guys i just don&#39;t wanna leave the swamp"}],
  32                    Jason.decode!(body)
  33                  )
  34
  35           # To make sure that the worker is called
  36           send(self(), "posted_to_meilisearch")
  37
  38           %{
  39             "enqueuedAt" => "2023-11-12T12:36:46.927517Z",
  40             "indexUid" => "objects",
  41             "status" => "enqueued",
  42             "taskUid" => 6,
  43             "type" => "documentAdditionOrUpdate"
  44           }
  45           |> json()
  46       end)
  47
  48       Config
  49       |> expect(:get, 3, fn
  50         [Pleroma.Search, :module], nil ->
  51           Meilisearch
  52
  53         [Pleroma.Search.Meilisearch, :url], nil ->
  54           "http://127.0.0.1:7700"
  55
  56         [Pleroma.Search.Meilisearch, :private_key], nil ->
  57           "secret"
  58       end)
  59
  60       {:ok, activity} =
  61         CommonAPI.post(user, %{
  62           status: "guys i just don't wanna leave the swamp",
  63           visibility: "public"
  64         })
  65
  66       args = %{"op" => "add_to_index", "activity" => activity.id}
  67
  68       assert_enqueued(
  69         worker: SearchIndexingWorker,
  70         args: args
  71       )
  72
  73       assert :ok = perform_job(SearchIndexingWorker, args)
  74       assert_received("posted_to_meilisearch")
  75     end
  76
  77     test "doesn't index posts that are not public" do
  78       user = insert(:user)
  79
  80       Enum.each(["private", "direct"], fn visibility ->
  81         {:ok, activity} =
  82           CommonAPI.post(user, %{
  83             status: "guys i just don't wanna leave the swamp",
  84             visibility: visibility
  85           })
  86
  87         args = %{"op" => "add_to_index", "activity" => activity.id}
  88
  89         Config
  90         |> expect(:get, fn
  91           [Pleroma.Search, :module], nil ->
  92             Meilisearch
  93         end)
  94
  95         assert_enqueued(worker: SearchIndexingWorker, args: args)
  96         assert :ok = perform_job(SearchIndexingWorker, args)
  97       end)
  98     end
  99
 100     test "deletes posts from index when deleted locally" do
 101       user = insert(:user)
 102
 103       Tesla.Mock.mock(fn
 104         %{
 105           method: :put,
 106           url: "http://127.0.0.1:7700/indexes/objects/documents",
 107           body: body
 108         } ->
 109           assert match?(
 110                    [%{"content" => "guys i just don&#39;t wanna leave the swamp"}],
 111                    Jason.decode!(body)
 112                  )
 113
 114           %{
 115             "enqueuedAt" => "2023-11-12T12:36:46.927517Z",
 116             "indexUid" => "objects",
 117             "status" => "enqueued",
 118             "taskUid" => 6,
 119             "type" => "documentAdditionOrUpdate"
 120           }
 121           |> json()
 122
 123         %{method: :delete, url: "http://127.0.0.1:7700/indexes/objects/documents/" <> id} ->
 124           send(self(), "called_delete")
 125           assert String.length(id) > 1
 126           json(%{})
 127       end)
 128
 129       Config
 130       |> expect(:get, 6, fn
 131         [Pleroma.Search, :module], nil ->
 132           Meilisearch
 133
 134         [Pleroma.Search.Meilisearch, :url], nil ->
 135           "http://127.0.0.1:7700"
 136
 137         [Pleroma.Search.Meilisearch, :private_key], nil ->
 138           "secret"
 139       end)
 140
 141       {:ok, activity} =
 142         CommonAPI.post(user, %{
 143           status: "guys i just don't wanna leave the swamp",
 144           visibility: "public"
 145         })
 146
 147       args = %{"op" => "add_to_index", "activity" => activity.id}
 148       assert_enqueued(worker: SearchIndexingWorker, args: args)
 149       assert :ok = perform_job(SearchIndexingWorker, args)
 150
 151       {:ok, _} = CommonAPI.delete(activity.id, user)
 152
 153       delete_args = %{"op" => "remove_from_index", "object" => activity.object.id}
 154       assert_enqueued(worker: SearchIndexingWorker, args: delete_args)
 155       assert :ok = perform_job(SearchIndexingWorker, delete_args)
 156
 157       assert_received("called_delete")
 158     end
 159   end
 160 end