git.squeep.com Git - akkoma/blob - test/web/mastodon_api/controllers/search_controller_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.Web.MastodonAPI.SearchControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Object
   9   alias Pleroma.Web
  10   alias Pleroma.Web.CommonAPI
  11   import Pleroma.Factory
  12   import ExUnit.CaptureLog
  13   import Tesla.Mock
  14   import Mock
  15
  16   setup do
  17     mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  18     :ok
  19   end
  20
  21   describe ".search2" do
  22     test "it returns empty result if user or status search return undefined error", %{conn: conn} do
  23       with_mocks [
  24         {Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
  25         {Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
  26       ] do
  27         capture_log(fn ->
  28           results =
  29             conn
  30             |> get("/api/v2/search", %{"q" => "2hu"})
  31             |> json_response(200)
  32
  33           assert results["accounts"] == []
  34           assert results["statuses"] == []
  35         end) =~
  36           "[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
  37       end
  38     end
  39
  40     test "search", %{conn: conn} do
  41       user = insert(:user)
  42       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
  43       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
  44
  45       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu private 天子"})
  46
  47       {:ok, _activity} =
  48         CommonAPI.post(user, %{
  49           "status" => "This is about 2hu, but private",
  50           "visibility" => "private"
  51         })
  52
  53       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
  54
  55       results =
  56         get(conn, "/api/v2/search", %{"q" => "2hu #private"})
  57         |> json_response(200)
  58
  59       [account | _] = results["accounts"]
  60       assert account["id"] == to_string(user_three.id)
  61
  62       assert results["hashtags"] == [
  63                %{"name" => "private", "url" => "#{Web.base_url()}/tag/private"}
  64              ]
  65
  66       [status] = results["statuses"]
  67       assert status["id"] == to_string(activity.id)
  68
  69       results =
  70         get(conn, "/api/v2/search", %{"q" => "天子"})
  71         |> json_response(200)
  72
  73       [status] = results["statuses"]
  74       assert status["id"] == to_string(activity.id)
  75     end
  76   end
  77
  78   describe ".account_search" do
  79     test "account search", %{conn: conn} do
  80       user = insert(:user)
  81       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
  82       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
  83
  84       results =
  85         conn
  86         |> assign(:user, user)
  87         |> get("/api/v1/accounts/search", %{"q" => "shp"})
  88         |> json_response(200)
  89
  90       result_ids = for result <- results, do: result["acct"]
  91
  92       assert user_two.nickname in result_ids
  93       assert user_three.nickname in result_ids
  94
  95       results =
  96         conn
  97         |> assign(:user, user)
  98         |> get("/api/v1/accounts/search", %{"q" => "2hu"})
  99         |> json_response(200)
 100
 101       result_ids = for result <- results, do: result["acct"]
 102
 103       assert user_three.nickname in result_ids
 104     end
 105
 106     test "returns account if query contains a space", %{conn: conn} do
 107       user = insert(:user, %{nickname: "shp@shitposter.club"})
 108
 109       results =
 110         conn
 111         |> assign(:user, user)
 112         |> get("/api/v1/accounts/search", %{"q" => "shp@shitposter.club xxx "})
 113         |> json_response(200)
 114
 115       assert length(results) == 1
 116     end
 117   end
 118
 119   describe ".search" do
 120     test "it returns empty result if user or status search return undefined error", %{conn: conn} do
 121       with_mocks [
 122         {Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
 123         {Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
 124       ] do
 125         capture_log(fn ->
 126           results =
 127             conn
 128             |> get("/api/v1/search", %{"q" => "2hu"})
 129             |> json_response(200)
 130
 131           assert results["accounts"] == []
 132           assert results["statuses"] == []
 133         end) =~
 134           "[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
 135       end
 136     end
 137
 138     test "search", %{conn: conn} do
 139       user = insert(:user)
 140       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 141       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 142
 143       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 144
 145       {:ok, _activity} =
 146         CommonAPI.post(user, %{
 147           "status" => "This is about 2hu, but private",
 148           "visibility" => "private"
 149         })
 150
 151       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 152
 153       conn =
 154         conn
 155         |> get("/api/v1/search", %{"q" => "2hu"})
 156
 157       assert results = json_response(conn, 200)
 158
 159       [account | _] = results["accounts"]
 160       assert account["id"] == to_string(user_three.id)
 161
 162       assert results["hashtags"] == []
 163
 164       [status] = results["statuses"]
 165       assert status["id"] == to_string(activity.id)
 166     end
 167
 168     test "search fetches remote statuses and prefers them over other results", %{conn: conn} do
 169       capture_log(fn ->
 170         {:ok, %{id: activity_id}} =
 171           CommonAPI.post(insert(:user), %{
 172             "status" => "check out https://shitposter.club/notice/2827873"
 173           })
 174
 175         conn =
 176           conn
 177           |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 178
 179         assert results = json_response(conn, 200)
 180
 181         [status, %{"id" => ^activity_id}] = results["statuses"]
 182
 183         assert status["uri"] ==
 184                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 185       end)
 186     end
 187
 188     test "search doesn't show statuses that it shouldn't", %{conn: conn} do
 189       {:ok, activity} =
 190         CommonAPI.post(insert(:user), %{
 191           "status" => "This is about 2hu, but private",
 192           "visibility" => "private"
 193         })
 194
 195       capture_log(fn ->
 196         conn =
 197           conn
 198           |> get("/api/v1/search", %{"q" => Object.normalize(activity).data["id"]})
 199
 200         assert results = json_response(conn, 200)
 201
 202         [] = results["statuses"]
 203       end)
 204     end
 205
 206     test "search fetches remote accounts", %{conn: conn} do
 207       user = insert(:user)
 208
 209       conn =
 210         conn
 211         |> assign(:user, user)
 212         |> get("/api/v1/search", %{"q" => "mike@osada.macgirvin.com", "resolve" => "true"})
 213
 214       assert results = json_response(conn, 200)
 215       [account] = results["accounts"]
 216       assert account["acct"] == "mike@osada.macgirvin.com"
 217     end
 218
 219     test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
 220       conn =
 221         conn
 222         |> get("/api/v1/search", %{"q" => "mike@osada.macgirvin.com", "resolve" => "false"})
 223
 224       assert results = json_response(conn, 200)
 225       assert [] == results["accounts"]
 226     end
 227
 228     test "search with limit and offset", %{conn: conn} do
 229       user = insert(:user)
 230       _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 231       _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 232
 233       {:ok, _activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 234       {:ok, _activity2} = CommonAPI.post(user, %{"status" => "This is also about 2hu"})
 235
 236       result =
 237         conn
 238         |> get("/api/v1/search", %{"q" => "2hu", "limit" => 1})
 239
 240       assert results = json_response(result, 200)
 241       assert [%{"id" => activity_id1}] = results["statuses"]
 242       assert [_] = results["accounts"]
 243
 244       results =
 245         conn
 246         |> get("/api/v1/search", %{"q" => "2hu", "limit" => 1, "offset" => 1})
 247         |> json_response(200)
 248
 249       assert [%{"id" => activity_id2}] = results["statuses"]
 250       assert [] = results["accounts"]
 251
 252       assert activity_id1 != activity_id2
 253     end
 254
 255     test "search returns results only for the given type", %{conn: conn} do
 256       user = insert(:user)
 257       _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 258
 259       {:ok, _activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 260
 261       assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
 262                conn
 263                |> get("/api/v1/search", %{"q" => "2hu", "type" => "statuses"})
 264                |> json_response(200)
 265
 266       assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
 267                conn
 268                |> get("/api/v1/search", %{"q" => "2hu", "type" => "accounts"})
 269                |> json_response(200)
 270     end
 271
 272     test "search uses account_id to filter statuses by the author", %{conn: conn} do
 273       user = insert(:user, %{nickname: "shp@shitposter.club"})
 274       user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 275
 276       {:ok, activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 277       {:ok, activity2} = CommonAPI.post(user_two, %{"status" => "This is also about 2hu"})
 278
 279       results =
 280         conn
 281         |> get("/api/v1/search", %{"q" => "2hu", "account_id" => user.id})
 282         |> json_response(200)
 283
 284       assert [%{"id" => activity_id1}] = results["statuses"]
 285       assert activity_id1 == activity1.id
 286       assert [_] = results["accounts"]
 287
 288       results =
 289         conn
 290         |> get("/api/v1/search", %{"q" => "2hu", "account_id" => user_two.id})
 291         |> json_response(200)
 292
 293       assert [%{"id" => activity_id2}] = results["statuses"]
 294       assert activity_id2 == activity2.id
 295     end
 296   end
 297 end