git.squeep.com Git - akkoma/blob - test/pleroma/web/mastodon_api/controllers/search_controller_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.Web.MastodonAPI.SearchControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Object
   9   alias Pleroma.Web.CommonAPI
  10   alias Pleroma.Web.Endpoint
  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" => "#{Endpoint.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       assert results["hashtags"] == [
  75                %{"name" => "天子", "url" => "#{Endpoint.url()}/tag/天子"}
  76              ]
  77
  78       [status] = results["statuses"]
  79       assert status["id"] == to_string(activity.id)
  80     end
  81
  82     @tag capture_log: true
  83     test "constructs hashtags from search query", %{conn: conn} do
  84       results =
  85         conn
  86         |> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
  87         |> json_response_and_validate_schema(200)
  88
  89       assert results["hashtags"] == [
  90                %{"name" => "explicit", "url" => "#{Endpoint.url()}/tag/explicit"},
  91                %{"name" => "hashtags", "url" => "#{Endpoint.url()}/tag/hashtags"}
  92              ]
  93
  94       results =
  95         conn
  96         |> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
  97         |> json_response_and_validate_schema(200)
  98
  99       assert results["hashtags"] == [
 100                %{"name" => "john", "url" => "#{Endpoint.url()}/tag/john"},
 101                %{"name" => "doe", "url" => "#{Endpoint.url()}/tag/doe"},
 102                %{"name" => "JohnDoe", "url" => "#{Endpoint.url()}/tag/JohnDoe"}
 103              ]
 104
 105       results =
 106         conn
 107         |> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
 108         |> json_response_and_validate_schema(200)
 109
 110       assert results["hashtags"] == [
 111                %{"name" => "accident", "url" => "#{Endpoint.url()}/tag/accident"},
 112                %{"name" => "prone", "url" => "#{Endpoint.url()}/tag/prone"},
 113                %{"name" => "AccidentProne", "url" => "#{Endpoint.url()}/tag/AccidentProne"}
 114              ]
 115
 116       results =
 117         conn
 118         |> get("/api/v2/search?#{URI.encode_query(%{q: "https://shpposter.club/users/shpuld"})}")
 119         |> json_response_and_validate_schema(200)
 120
 121       assert results["hashtags"] == [
 122                %{"name" => "shpuld", "url" => "#{Endpoint.url()}/tag/shpuld"}
 123              ]
 124
 125       results =
 126         conn
 127         |> get(
 128           "/api/v2/search?#{
 129             URI.encode_query(%{
 130               q:
 131                 "https://www.washingtonpost.com/sports/2020/06/10/" <>
 132                   "nascar-ban-display-confederate-flag-all-events-properties/"
 133             })
 134           }"
 135         )
 136         |> json_response_and_validate_schema(200)
 137
 138       assert results["hashtags"] == [
 139                %{"name" => "nascar", "url" => "#{Endpoint.url()}/tag/nascar"},
 140                %{"name" => "ban", "url" => "#{Endpoint.url()}/tag/ban"},
 141                %{"name" => "display", "url" => "#{Endpoint.url()}/tag/display"},
 142                %{"name" => "confederate", "url" => "#{Endpoint.url()}/tag/confederate"},
 143                %{"name" => "flag", "url" => "#{Endpoint.url()}/tag/flag"},
 144                %{"name" => "all", "url" => "#{Endpoint.url()}/tag/all"},
 145                %{"name" => "events", "url" => "#{Endpoint.url()}/tag/events"},
 146                %{"name" => "properties", "url" => "#{Endpoint.url()}/tag/properties"},
 147                %{
 148                  "name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
 149                  "url" =>
 150                    "#{Endpoint.url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
 151                }
 152              ]
 153     end
 154
 155     test "supports pagination of hashtags search results", %{conn: conn} do
 156       results =
 157         conn
 158         |> get(
 159           "/api/v2/search?#{
 160             URI.encode_query(%{q: "#some #text #with #hashtags", limit: 2, offset: 1})
 161           }"
 162         )
 163         |> json_response_and_validate_schema(200)
 164
 165       assert results["hashtags"] == [
 166                %{"name" => "text", "url" => "#{Endpoint.url()}/tag/text"},
 167                %{"name" => "with", "url" => "#{Endpoint.url()}/tag/with"}
 168              ]
 169     end
 170
 171     test "excludes a blocked users from search results", %{conn: conn} do
 172       user = insert(:user)
 173       user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
 174       user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})
 175
 176       {:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
 177       {:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
 178       {:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
 179       Pleroma.User.block(user, user_smith)
 180
 181       results =
 182         conn
 183         |> assign(:user, user)
 184         |> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
 185         |> get("/api/v2/search?q=Agent")
 186         |> json_response_and_validate_schema(200)
 187
 188       status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)
 189
 190       assert act3.id in status_ids
 191       refute act2.id in status_ids
 192       refute act1.id in status_ids
 193     end
 194   end
 195
 196   describe ".account_search" do
 197     test "account search", %{conn: conn} do
 198       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 199       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 200
 201       results =
 202         conn
 203         |> get("/api/v1/accounts/search?q=shp")
 204         |> json_response_and_validate_schema(200)
 205
 206       result_ids = for result <- results, do: result["acct"]
 207
 208       assert user_two.nickname in result_ids
 209       assert user_three.nickname in result_ids
 210
 211       results =
 212         conn
 213         |> get("/api/v1/accounts/search?q=2hu")
 214         |> json_response_and_validate_schema(200)
 215
 216       result_ids = for result <- results, do: result["acct"]
 217
 218       assert user_three.nickname in result_ids
 219     end
 220
 221     test "returns account if query contains a space", %{conn: conn} do
 222       insert(:user, %{nickname: "shp@shitposter.club"})
 223
 224       results =
 225         conn
 226         |> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
 227         |> json_response_and_validate_schema(200)
 228
 229       assert length(results) == 1
 230     end
 231   end
 232
 233   describe ".search" do
 234     test "it returns empty result if user or status search return undefined error", %{conn: conn} do
 235       with_mocks [
 236         {Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
 237         {Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
 238       ] do
 239         capture_log(fn ->
 240           results =
 241             conn
 242             |> get("/api/v1/search?q=2hu")
 243             |> json_response_and_validate_schema(200)
 244
 245           assert results["accounts"] == []
 246           assert results["statuses"] == []
 247         end) =~
 248           "[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
 249       end
 250     end
 251
 252     test "search", %{conn: conn} do
 253       user = insert(:user)
 254       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 255       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 256
 257       {:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 258
 259       {:ok, _activity} =
 260         CommonAPI.post(user, %{
 261           status: "This is about 2hu, but private",
 262           visibility: "private"
 263         })
 264
 265       {:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})
 266
 267       results =
 268         conn
 269         |> get("/api/v1/search?q=2hu")
 270         |> json_response_and_validate_schema(200)
 271
 272       [account | _] = results["accounts"]
 273       assert account["id"] == to_string(user_three.id)
 274
 275       assert results["hashtags"] == ["2hu"]
 276
 277       [status] = results["statuses"]
 278       assert status["id"] == to_string(activity.id)
 279     end
 280
 281     test "search fetches remote statuses and prefers them over other results", %{conn: conn} do
 282       old_version = :persistent_term.get({Pleroma.Repo, :postgres_version})
 283       :persistent_term.put({Pleroma.Repo, :postgres_version}, 10.0)
 284       on_exit(fn -> :persistent_term.put({Pleroma.Repo, :postgres_version}, old_version) end)
 285
 286       capture_log(fn ->
 287         {:ok, %{id: activity_id}} =
 288           CommonAPI.post(insert(:user), %{
 289             status: "check out http://mastodon.example.org/@admin/99541947525187367"
 290           })
 291
 292         results =
 293           conn
 294           |> get("/api/v1/search?q=http://mastodon.example.org/@admin/99541947525187367")
 295           |> json_response_and_validate_schema(200)
 296
 297         assert [
 298                  %{"url" => "http://mastodon.example.org/@admin/99541947525187367"},
 299                  %{"id" => ^activity_id}
 300                ] = results["statuses"]
 301       end)
 302     end
 303
 304     test "search doesn't show statuses that it shouldn't", %{conn: conn} do
 305       {:ok, activity} =
 306         CommonAPI.post(insert(:user), %{
 307           status: "This is about 2hu, but private",
 308           visibility: "private"
 309         })
 310
 311       capture_log(fn ->
 312         q = Object.normalize(activity, fetch: false).data["id"]
 313
 314         results =
 315           conn
 316           |> get("/api/v1/search?q=#{q}")
 317           |> json_response_and_validate_schema(200)
 318
 319         [] = results["statuses"]
 320       end)
 321     end
 322
 323     test "search fetches remote accounts", %{conn: conn} do
 324       user = insert(:user)
 325
 326       query = URI.encode_query(%{q: "       mike@osada.macgirvin.com          ", resolve: true})
 327
 328       results =
 329         conn
 330         |> assign(:user, user)
 331         |> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
 332         |> get("/api/v1/search?#{query}")
 333         |> json_response_and_validate_schema(200)
 334
 335       [account] = results["accounts"]
 336       assert account["acct"] == "mike@osada.macgirvin.com"
 337     end
 338
 339     test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
 340       results =
 341         conn
 342         |> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
 343         |> json_response_and_validate_schema(200)
 344
 345       assert [] == results["accounts"]
 346     end
 347
 348     test "search with limit and offset", %{conn: conn} do
 349       user = insert(:user)
 350       _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 351       _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 352
 353       {:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
 354       {:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})
 355
 356       result =
 357         conn
 358         |> get("/api/v1/search?q=2hu&limit=1")
 359
 360       assert results = json_response_and_validate_schema(result, 200)
 361       assert [%{"id" => activity_id1}] = results["statuses"]
 362       assert [_] = results["accounts"]
 363
 364       results =
 365         conn
 366         |> get("/api/v1/search?q=2hu&limit=1&offset=1")
 367         |> json_response_and_validate_schema(200)
 368
 369       assert [%{"id" => activity_id2}] = results["statuses"]
 370       assert [] = results["accounts"]
 371
 372       assert activity_id1 != activity_id2
 373     end
 374
 375     test "search returns results only for the given type", %{conn: conn} do
 376       user = insert(:user)
 377       _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 378
 379       {:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 380
 381       assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
 382                conn
 383                |> get("/api/v1/search?q=2hu&type=statuses")
 384                |> json_response_and_validate_schema(200)
 385
 386       assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
 387                conn
 388                |> get("/api/v1/search?q=2hu&type=accounts")
 389                |> json_response_and_validate_schema(200)
 390     end
 391
 392     test "search uses account_id to filter statuses by the author", %{conn: conn} do
 393       user = insert(:user, %{nickname: "shp@shitposter.club"})
 394       user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 395
 396       {:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
 397       {:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})
 398
 399       results =
 400         conn
 401         |> get("/api/v1/search?q=2hu&account_id=#{user.id}")
 402         |> json_response_and_validate_schema(200)
 403
 404       assert [%{"id" => activity_id1}] = results["statuses"]
 405       assert activity_id1 == activity1.id
 406       assert [_] = results["accounts"]
 407
 408       results =
 409         conn
 410         |> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
 411         |> json_response_and_validate_schema(200)
 412
 413       assert [%{"id" => activity_id2}] = results["statuses"]
 414       assert activity_id2 == activity2.id
 415     end
 416   end
 417 end