Git of dcc - anni/blob - test/pleroma/web/mastodon_api/controllers/search_controller_test.exs

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