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", %{conn: conn} do
 169       capture_log(fn ->
 170         conn =
 171           conn
 172           |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 173
 174         assert results = json_response(conn, 200)
 175
 176         [status] = results["statuses"]
 177
 178         assert status["uri"] ==
 179                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 180       end)
 181     end
 182
 183     test "search doesn't show statuses that it shouldn't", %{conn: conn} do
 184       {:ok, activity} =
 185         CommonAPI.post(insert(:user), %{
 186           "status" => "This is about 2hu, but private",
 187           "visibility" => "private"
 188         })
 189
 190       capture_log(fn ->
 191         conn =
 192           conn
 193           |> get("/api/v1/search", %{"q" => Object.normalize(activity).data["id"]})
 194
 195         assert results = json_response(conn, 200)
 196
 197         [] = results["statuses"]
 198       end)
 199     end
 200
 201     test "search fetches remote accounts", %{conn: conn} do
 202       user = insert(:user)
 203
 204       conn =
 205         conn
 206         |> assign(:user, user)
 207         |> get("/api/v1/search", %{"q" => "mike@osada.macgirvin.com", "resolve" => "true"})
 208
 209       assert results = json_response(conn, 200)
 210       [account] = results["accounts"]
 211       assert account["acct"] == "mike@osada.macgirvin.com"
 212     end
 213
 214     test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
 215       conn =
 216         conn
 217         |> get("/api/v1/search", %{"q" => "mike@osada.macgirvin.com", "resolve" => "false"})
 218
 219       assert results = json_response(conn, 200)
 220       assert [] == results["accounts"]
 221     end
 222
 223     test "search with limit and offset", %{conn: conn} do
 224       user = insert(:user)
 225       _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 226       _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 227
 228       {:ok, _activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 229       {:ok, _activity2} = CommonAPI.post(user, %{"status" => "This is also about 2hu"})
 230
 231       result =
 232         conn
 233         |> get("/api/v1/search", %{"q" => "2hu", "limit" => 1})
 234
 235       assert results = json_response(result, 200)
 236       assert [%{"id" => activity_id1}] = results["statuses"]
 237       assert [_] = results["accounts"]
 238
 239       results =
 240         conn
 241         |> get("/api/v1/search", %{"q" => "2hu", "limit" => 1, "offset" => 1})
 242         |> json_response(200)
 243
 244       assert [%{"id" => activity_id2}] = results["statuses"]
 245       assert [] = results["accounts"]
 246
 247       assert activity_id1 != activity_id2
 248     end
 249
 250     test "search returns results only for the given type", %{conn: conn} do
 251       user = insert(:user)
 252       _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 253
 254       {:ok, _activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 255
 256       assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
 257                conn
 258                |> get("/api/v1/search", %{"q" => "2hu", "type" => "statuses"})
 259                |> json_response(200)
 260
 261       assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
 262                conn
 263                |> get("/api/v1/search", %{"q" => "2hu", "type" => "accounts"})
 264                |> json_response(200)
 265     end
 266
 267     test "search uses account_id to filter statuses by the author", %{conn: conn} do
 268       user = insert(:user, %{nickname: "shp@shitposter.club"})
 269       user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 270
 271       {:ok, activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 272       {:ok, activity2} = CommonAPI.post(user_two, %{"status" => "This is also about 2hu"})
 273
 274       results =
 275         conn
 276         |> get("/api/v1/search", %{"q" => "2hu", "account_id" => user.id})
 277         |> json_response(200)
 278
 279       assert [%{"id" => activity_id1}] = results["statuses"]
 280       assert activity_id1 == activity1.id
 281       assert [_] = results["accounts"]
 282
 283       results =
 284         conn
 285         |> get("/api/v1/search", %{"q" => "2hu", "account_id" => user_two.id})
 286         |> json_response(200)
 287
 288       assert [%{"id" => activity_id2}] = results["statuses"]
 289       assert activity_id2 == activity2.id
 290     end
 291   end
 292 end