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