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-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       assert results["hashtags"] == [
  75                %{"name" => "天子", "url" => "#{Web.base_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" => "#{Web.base_url()}/tag/explicit"},
  91                %{"name" => "hashtags", "url" => "#{Web.base_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" => "#{Web.base_url()}/tag/john"},
 101                %{"name" => "doe", "url" => "#{Web.base_url()}/tag/doe"},
 102                %{"name" => "JohnDoe", "url" => "#{Web.base_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" => "#{Web.base_url()}/tag/accident"},
 112                %{"name" => "prone", "url" => "#{Web.base_url()}/tag/prone"},
 113                %{"name" => "AccidentProne", "url" => "#{Web.base_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" => "#{Web.base_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" => "#{Web.base_url()}/tag/nascar"},
 140                %{"name" => "ban", "url" => "#{Web.base_url()}/tag/ban"},
 141                %{"name" => "display", "url" => "#{Web.base_url()}/tag/display"},
 142                %{"name" => "confederate", "url" => "#{Web.base_url()}/tag/confederate"},
 143                %{"name" => "flag", "url" => "#{Web.base_url()}/tag/flag"},
 144                %{"name" => "all", "url" => "#{Web.base_url()}/tag/all"},
 145                %{"name" => "events", "url" => "#{Web.base_url()}/tag/events"},
 146                %{"name" => "properties", "url" => "#{Web.base_url()}/tag/properties"},
 147                %{
 148                  "name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
 149                  "url" =>
 150                    "#{Web.base_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" => "#{Web.base_url()}/tag/text"},
 167                %{"name" => "with", "url" => "#{Web.base_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       capture_log(fn ->
 283         {:ok, %{id: activity_id}} =
 284           CommonAPI.post(insert(:user), %{
 285             status: "check out http://mastodon.example.org/@admin/99541947525187367"
 286           })
 287
 288         results =
 289           conn
 290           |> get("/api/v1/search?q=http://mastodon.example.org/@admin/99541947525187367")
 291           |> json_response_and_validate_schema(200)
 292
 293         assert [
 294                  %{"url" => "http://mastodon.example.org/@admin/99541947525187367"},
 295                  %{"id" => ^activity_id}
 296                ] = results["statuses"]
 297       end)
 298     end
 299
 300     test "search doesn't show statuses that it shouldn't", %{conn: conn} do
 301       {:ok, activity} =
 302         CommonAPI.post(insert(:user), %{
 303           status: "This is about 2hu, but private",
 304           visibility: "private"
 305         })
 306
 307       capture_log(fn ->
 308         q = Object.normalize(activity).data["id"]
 309
 310         results =
 311           conn
 312           |> get("/api/v1/search?q=#{q}")
 313           |> json_response_and_validate_schema(200)
 314
 315         [] = results["statuses"]
 316       end)
 317     end
 318
 319     test "search fetches remote accounts", %{conn: conn} do
 320       user = insert(:user)
 321
 322       query = URI.encode_query(%{q: "       mike@osada.macgirvin.com          ", resolve: true})
 323
 324       results =
 325         conn
 326         |> assign(:user, user)
 327         |> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
 328         |> get("/api/v1/search?#{query}")
 329         |> json_response_and_validate_schema(200)
 330
 331       [account] = results["accounts"]
 332       assert account["acct"] == "mike@osada.macgirvin.com"
 333     end
 334
 335     test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
 336       results =
 337         conn
 338         |> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
 339         |> json_response_and_validate_schema(200)
 340
 341       assert [] == results["accounts"]
 342     end
 343
 344     test "search with limit and offset", %{conn: conn} do
 345       user = insert(:user)
 346       _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 347       _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 348
 349       {:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
 350       {:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})
 351
 352       result =
 353         conn
 354         |> get("/api/v1/search?q=2hu&limit=1")
 355
 356       assert results = json_response_and_validate_schema(result, 200)
 357       assert [%{"id" => activity_id1}] = results["statuses"]
 358       assert [_] = results["accounts"]
 359
 360       results =
 361         conn
 362         |> get("/api/v1/search?q=2hu&limit=1&offset=1")
 363         |> json_response_and_validate_schema(200)
 364
 365       assert [%{"id" => activity_id2}] = results["statuses"]
 366       assert [] = results["accounts"]
 367
 368       assert activity_id1 != activity_id2
 369     end
 370
 371     test "search returns results only for the given type", %{conn: conn} do
 372       user = insert(:user)
 373       _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 374
 375       {:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 376
 377       assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
 378                conn
 379                |> get("/api/v1/search?q=2hu&type=statuses")
 380                |> json_response_and_validate_schema(200)
 381
 382       assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
 383                conn
 384                |> get("/api/v1/search?q=2hu&type=accounts")
 385                |> json_response_and_validate_schema(200)
 386     end
 387
 388     test "search uses account_id to filter statuses by the author", %{conn: conn} do
 389       user = insert(:user, %{nickname: "shp@shitposter.club"})
 390       user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 391
 392       {:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
 393       {:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})
 394
 395       results =
 396         conn
 397         |> get("/api/v1/search?q=2hu&account_id=#{user.id}")
 398         |> json_response_and_validate_schema(200)
 399
 400       assert [%{"id" => activity_id1}] = results["statuses"]
 401       assert activity_id1 == activity1.id
 402       assert [_] = results["accounts"]
 403
 404       results =
 405         conn
 406         |> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
 407         |> json_response_and_validate_schema(200)
 408
 409       assert [%{"id" => activity_id2}] = results["statuses"]
 410       assert activity_id2 == activity2.id
 411     end
 412   end
 413 end