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