git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Config
   9   alias Pleroma.Notification
  10   alias Pleroma.Repo
  11   alias Pleroma.User
  12   alias Pleroma.Web.CommonAPI
  13
  14   import Pleroma.Factory
  15   import Tesla.Mock
  16
  17   setup do
  18     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  19     :ok
  20   end
  21
  22   clear_config([:instance, :public])
  23   clear_config([:rich_media, :enabled])
  24
  25   test "getting a list of mutes", %{conn: conn} do
  26     user = insert(:user)
  27     other_user = insert(:user)
  28
  29     {:ok, user} = User.mute(user, other_user)
  30
  31     conn =
  32       conn
  33       |> assign(:user, user)
  34       |> get("/api/v1/mutes")
  35
  36     other_user_id = to_string(other_user.id)
  37     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
  38   end
  39
  40   test "getting a list of blocks", %{conn: conn} do
  41     user = insert(:user)
  42     other_user = insert(:user)
  43
  44     {:ok, user} = User.block(user, other_user)
  45
  46     conn =
  47       conn
  48       |> assign(:user, user)
  49       |> get("/api/v1/blocks")
  50
  51     other_user_id = to_string(other_user.id)
  52     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
  53   end
  54
  55   test "unimplemented follow_requests, blocks, domain blocks" do
  56     user = insert(:user)
  57
  58     ["blocks", "domain_blocks", "follow_requests"]
  59     |> Enum.each(fn endpoint ->
  60       conn =
  61         build_conn()
  62         |> assign(:user, user)
  63         |> get("/api/v1/#{endpoint}")
  64
  65       assert [] = json_response(conn, 200)
  66     end)
  67   end
  68
  69   test "returns the favorites of a user", %{conn: conn} do
  70     user = insert(:user)
  71     other_user = insert(:user)
  72
  73     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
  74     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
  75
  76     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
  77
  78     first_conn =
  79       conn
  80       |> assign(:user, user)
  81       |> get("/api/v1/favourites")
  82
  83     assert [status] = json_response(first_conn, 200)
  84     assert status["id"] == to_string(activity.id)
  85
  86     assert [{"link", _link_header}] =
  87              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
  88
  89     # Honours query params
  90     {:ok, second_activity} =
  91       CommonAPI.post(other_user, %{
  92         "status" =>
  93           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
  94       })
  95
  96     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
  97
  98     last_like = status["id"]
  99
 100     second_conn =
 101       conn
 102       |> assign(:user, user)
 103       |> get("/api/v1/favourites?since_id=#{last_like}")
 104
 105     assert [second_status] = json_response(second_conn, 200)
 106     assert second_status["id"] == to_string(second_activity.id)
 107
 108     third_conn =
 109       conn
 110       |> assign(:user, user)
 111       |> get("/api/v1/favourites?limit=0")
 112
 113     assert [] = json_response(third_conn, 200)
 114   end
 115
 116   test "put settings", %{conn: conn} do
 117     user = insert(:user)
 118
 119     conn =
 120       conn
 121       |> assign(:user, user)
 122       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
 123
 124     assert _result = json_response(conn, 200)
 125
 126     user = User.get_cached_by_ap_id(user.ap_id)
 127     assert user.info.settings == %{"programming" => "socks"}
 128   end
 129
 130   describe "link headers" do
 131     test "preserves parameters in link headers", %{conn: conn} do
 132       user = insert(:user)
 133       other_user = insert(:user)
 134
 135       {:ok, activity1} =
 136         CommonAPI.post(other_user, %{
 137           "status" => "hi @#{user.nickname}",
 138           "visibility" => "public"
 139         })
 140
 141       {:ok, activity2} =
 142         CommonAPI.post(other_user, %{
 143           "status" => "hi @#{user.nickname}",
 144           "visibility" => "public"
 145         })
 146
 147       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
 148       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
 149
 150       conn =
 151         conn
 152         |> assign(:user, user)
 153         |> get("/api/v1/notifications", %{media_only: true})
 154
 155       assert [link_header] = get_resp_header(conn, "link")
 156       assert link_header =~ ~r/media_only=true/
 157       assert link_header =~ ~r/min_id=#{notification2.id}/
 158       assert link_header =~ ~r/max_id=#{notification1.id}/
 159     end
 160   end
 161
 162   describe "custom emoji" do
 163     test "with tags", %{conn: conn} do
 164       [emoji | _body] =
 165         conn
 166         |> get("/api/v1/custom_emojis")
 167         |> json_response(200)
 168
 169       assert Map.has_key?(emoji, "shortcode")
 170       assert Map.has_key?(emoji, "static_url")
 171       assert Map.has_key?(emoji, "tags")
 172       assert is_list(emoji["tags"])
 173       assert Map.has_key?(emoji, "category")
 174       assert Map.has_key?(emoji, "url")
 175       assert Map.has_key?(emoji, "visible_in_picker")
 176     end
 177   end
 178
 179   describe "index/2 redirections" do
 180     setup %{conn: conn} do
 181       session_opts = [
 182         store: :cookie,
 183         key: "_test",
 184         signing_salt: "cooldude"
 185       ]
 186
 187       conn =
 188         conn
 189         |> Plug.Session.call(Plug.Session.init(session_opts))
 190         |> fetch_session()
 191
 192       test_path = "/web/statuses/test"
 193       %{conn: conn, path: test_path}
 194     end
 195
 196     test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
 197       conn = get(conn, path)
 198
 199       assert conn.status == 302
 200       assert redirected_to(conn) == "/web/login"
 201     end
 202
 203     test "redirects not logged-in users to the login page on private instances", %{
 204       conn: conn,
 205       path: path
 206     } do
 207       Config.put([:instance, :public], false)
 208
 209       conn = get(conn, path)
 210
 211       assert conn.status == 302
 212       assert redirected_to(conn) == "/web/login"
 213     end
 214
 215     test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
 216       token = insert(:oauth_token)
 217
 218       conn =
 219         conn
 220         |> assign(:user, token.user)
 221         |> put_session(:oauth_token, token.token)
 222         |> get(path)
 223
 224       assert conn.status == 200
 225     end
 226
 227     test "saves referer path to session", %{conn: conn, path: path} do
 228       conn = get(conn, path)
 229       return_to = Plug.Conn.get_session(conn, :return_to)
 230
 231       assert return_to == path
 232     end
 233   end
 234
 235   describe "empty_array, stubs for mastodon api" do
 236     test "GET /api/v1/accounts/:id/identity_proofs", %{conn: conn} do
 237       user = insert(:user)
 238
 239       res =
 240         conn
 241         |> assign(:user, user)
 242         |> get("/api/v1/accounts/#{user.id}/identity_proofs")
 243         |> json_response(200)
 244
 245       assert res == []
 246     end
 247
 248     test "GET /api/v1/endorsements", %{conn: conn} do
 249       user = insert(:user)
 250
 251       res =
 252         conn
 253         |> assign(:user, user)
 254         |> get("/api/v1/endorsements")
 255         |> json_response(200)
 256
 257       assert res == []
 258     end
 259
 260     test "GET /api/v1/trends", %{conn: conn} do
 261       user = insert(:user)
 262
 263       res =
 264         conn
 265         |> assign(:user, user)
 266         |> get("/api/v1/trends")
 267         |> json_response(200)
 268
 269       assert res == []
 270     end
 271   end
 272 end