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-2020 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_all 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_and_validate_schema(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         conn
  57         |> get("/api/v2/search?#{URI.encode_query(%{q: "2hu #private"})}")
  58         |> json_response_and_validate_schema(200)
  59
  60       [account | _] = results["accounts"]
  61       assert account["id"] == to_string(user_three.id)
  62
  63       assert results["hashtags"] == [
  64                %{"name" => "private", "url" => "#{Web.base_url()}/tag/private"}
  65              ]
  66
  67       [status] = results["statuses"]
  68       assert status["id"] == to_string(activity.id)
  69
  70       results =
  71         get(conn, "/api/v2/search?q=天子")
  72         |> json_response_and_validate_schema(200)
  73
  74       [status] = results["statuses"]
  75       assert status["id"] == to_string(activity.id)
  76     end
  77
  78     test "constructs hashtags from search query", %{conn: conn} do
  79       results =
  80         conn
  81         |> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
  82         |> json_response_and_validate_schema(200)
  83
  84       assert results["hashtags"] == [
  85                %{"name" => "explicit", "url" => "#{Web.base_url()}/tag/explicit"},
  86                %{"name" => "hashtags", "url" => "#{Web.base_url()}/tag/hashtags"}
  87              ]
  88
  89       results =
  90         conn
  91         |> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
  92         |> json_response_and_validate_schema(200)
  93
  94       assert results["hashtags"] == [
  95                %{"name" => "john", "url" => "#{Web.base_url()}/tag/john"},
  96                %{"name" => "doe", "url" => "#{Web.base_url()}/tag/doe"},
  97                %{"name" => "JohnDoe", "url" => "#{Web.base_url()}/tag/JohnDoe"}
  98              ]
  99
 100       results =
 101         conn
 102         |> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
 103         |> json_response_and_validate_schema(200)
 104
 105       assert results["hashtags"] == [
 106                %{"name" => "accident", "url" => "#{Web.base_url()}/tag/accident"},
 107                %{"name" => "prone", "url" => "#{Web.base_url()}/tag/prone"},
 108                %{"name" => "AccidentProne", "url" => "#{Web.base_url()}/tag/AccidentProne"}
 109              ]
 110     end
 111
 112     test "excludes a blocked users from search results", %{conn: conn} do
 113       user = insert(:user)
 114       user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
 115       user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})
 116
 117       {:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
 118       {:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
 119       {:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
 120       Pleroma.User.block(user, user_smith)
 121
 122       results =
 123         conn
 124         |> assign(:user, user)
 125         |> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
 126         |> get("/api/v2/search?q=Agent")
 127         |> json_response_and_validate_schema(200)
 128
 129       status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)
 130
 131       assert act3.id in status_ids
 132       refute act2.id in status_ids
 133       refute act1.id in status_ids
 134     end
 135   end
 136
 137   describe ".account_search" do
 138     test "account search", %{conn: conn} do
 139       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 140       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 141
 142       results =
 143         conn
 144         |> get("/api/v1/accounts/search?q=shp")
 145         |> json_response_and_validate_schema(200)
 146
 147       result_ids = for result <- results, do: result["acct"]
 148
 149       assert user_two.nickname in result_ids
 150       assert user_three.nickname in result_ids
 151
 152       results =
 153         conn
 154         |> get("/api/v1/accounts/search?q=2hu")
 155         |> json_response_and_validate_schema(200)
 156
 157       result_ids = for result <- results, do: result["acct"]
 158
 159       assert user_three.nickname in result_ids
 160     end
 161
 162     test "returns account if query contains a space", %{conn: conn} do
 163       insert(:user, %{nickname: "shp@shitposter.club"})
 164
 165       results =
 166         conn
 167         |> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
 168         |> json_response_and_validate_schema(200)
 169
 170       assert length(results) == 1
 171     end
 172   end
 173
 174   describe ".search" do
 175     test "it returns empty result if user or status search return undefined error", %{conn: conn} do
 176       with_mocks [
 177         {Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
 178         {Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
 179       ] do
 180         capture_log(fn ->
 181           results =
 182             conn
 183             |> get("/api/v1/search?q=2hu")
 184             |> json_response_and_validate_schema(200)
 185
 186           assert results["accounts"] == []
 187           assert results["statuses"] == []
 188         end) =~
 189           "[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
 190       end
 191     end
 192
 193     test "search", %{conn: conn} do
 194       user = insert(:user)
 195       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 196       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 197
 198       {:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 199
 200       {:ok, _activity} =
 201         CommonAPI.post(user, %{
 202           status: "This is about 2hu, but private",
 203           visibility: "private"
 204         })
 205
 206       {:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})
 207
 208       results =
 209         conn
 210         |> get("/api/v1/search?q=2hu")
 211         |> json_response_and_validate_schema(200)
 212
 213       [account | _] = results["accounts"]
 214       assert account["id"] == to_string(user_three.id)
 215
 216       assert results["hashtags"] == ["2hu"]
 217
 218       [status] = results["statuses"]
 219       assert status["id"] == to_string(activity.id)
 220     end
 221
 222     test "search fetches remote statuses and prefers them over other results", %{conn: conn} do
 223       capture_log(fn ->
 224         {:ok, %{id: activity_id}} =
 225           CommonAPI.post(insert(:user), %{
 226             status: "check out https://shitposter.club/notice/2827873"
 227           })
 228
 229         results =
 230           conn
 231           |> get("/api/v1/search?q=https://shitposter.club/notice/2827873")
 232           |> json_response_and_validate_schema(200)
 233
 234         [status, %{"id" => ^activity_id}] = results["statuses"]
 235
 236         assert status["uri"] ==
 237                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 238       end)
 239     end
 240
 241     test "search doesn't show statuses that it shouldn't", %{conn: conn} do
 242       {:ok, activity} =
 243         CommonAPI.post(insert(:user), %{
 244           status: "This is about 2hu, but private",
 245           visibility: "private"
 246         })
 247
 248       capture_log(fn ->
 249         q = Object.normalize(activity).data["id"]
 250
 251         results =
 252           conn
 253           |> get("/api/v1/search?q=#{q}")
 254           |> json_response_and_validate_schema(200)
 255
 256         [] = results["statuses"]
 257       end)
 258     end
 259
 260     test "search fetches remote accounts", %{conn: conn} do
 261       user = insert(:user)
 262
 263       results =
 264         conn
 265         |> assign(:user, user)
 266         |> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
 267         |> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=true")
 268         |> json_response_and_validate_schema(200)
 269
 270       [account] = results["accounts"]
 271       assert account["acct"] == "mike@osada.macgirvin.com"
 272     end
 273
 274     test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
 275       results =
 276         conn
 277         |> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
 278         |> json_response_and_validate_schema(200)
 279
 280       assert [] == results["accounts"]
 281     end
 282
 283     test "search with limit and offset", %{conn: conn} do
 284       user = insert(:user)
 285       _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 286       _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 287
 288       {:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
 289       {:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})
 290
 291       result =
 292         conn
 293         |> get("/api/v1/search?q=2hu&limit=1")
 294
 295       assert results = json_response_and_validate_schema(result, 200)
 296       assert [%{"id" => activity_id1}] = results["statuses"]
 297       assert [_] = results["accounts"]
 298
 299       results =
 300         conn
 301         |> get("/api/v1/search?q=2hu&limit=1&offset=1")
 302         |> json_response_and_validate_schema(200)
 303
 304       assert [%{"id" => activity_id2}] = results["statuses"]
 305       assert [] = results["accounts"]
 306
 307       assert activity_id1 != activity_id2
 308     end
 309
 310     test "search returns results only for the given type", %{conn: conn} do
 311       user = insert(:user)
 312       _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 313
 314       {:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 315
 316       assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
 317                conn
 318                |> get("/api/v1/search?q=2hu&type=statuses")
 319                |> json_response_and_validate_schema(200)
 320
 321       assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
 322                conn
 323                |> get("/api/v1/search?q=2hu&type=accounts")
 324                |> json_response_and_validate_schema(200)
 325     end
 326
 327     test "search uses account_id to filter statuses by the author", %{conn: conn} do
 328       user = insert(:user, %{nickname: "shp@shitposter.club"})
 329       user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 330
 331       {:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
 332       {:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})
 333
 334       results =
 335         conn
 336         |> get("/api/v1/search?q=2hu&account_id=#{user.id}")
 337         |> json_response_and_validate_schema(200)
 338
 339       assert [%{"id" => activity_id1}] = results["statuses"]
 340       assert activity_id1 == activity1.id
 341       assert [_] = results["accounts"]
 342
 343       results =
 344         conn
 345         |> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
 346         |> json_response_and_validate_schema(200)
 347
 348       assert [%{"id" => activity_id2}] = results["statuses"]
 349       assert activity_id2 == activity2.id
 350     end
 351   end
 352 end