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.Notification
   9   alias Pleroma.Repo
  10   alias Pleroma.User
  11   alias Pleroma.Web.CommonAPI
  12
  13   import Pleroma.Factory
  14   import Tesla.Mock
  15
  16   setup do
  17     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  18     :ok
  19   end
  20
  21   clear_config([:rich_media, :enabled])
  22
  23   test "getting a list of mutes", %{conn: conn} do
  24     user = insert(:user)
  25     other_user = insert(:user)
  26
  27     {:ok, user} = User.mute(user, other_user)
  28
  29     conn =
  30       conn
  31       |> assign(:user, user)
  32       |> get("/api/v1/mutes")
  33
  34     other_user_id = to_string(other_user.id)
  35     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
  36   end
  37
  38   test "getting a list of blocks", %{conn: conn} do
  39     user = insert(:user)
  40     other_user = insert(:user)
  41
  42     {:ok, user} = User.block(user, other_user)
  43
  44     conn =
  45       conn
  46       |> assign(:user, user)
  47       |> get("/api/v1/blocks")
  48
  49     other_user_id = to_string(other_user.id)
  50     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
  51   end
  52
  53   test "unimplemented follow_requests, blocks, domain blocks" do
  54     user = insert(:user)
  55
  56     ["blocks", "domain_blocks", "follow_requests"]
  57     |> Enum.each(fn endpoint ->
  58       conn =
  59         build_conn()
  60         |> assign(:user, user)
  61         |> get("/api/v1/#{endpoint}")
  62
  63       assert [] = json_response(conn, 200)
  64     end)
  65   end
  66
  67   test "returns the favorites of a user", %{conn: conn} do
  68     user = insert(:user)
  69     other_user = insert(:user)
  70
  71     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
  72     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
  73
  74     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
  75
  76     first_conn =
  77       conn
  78       |> assign(:user, user)
  79       |> get("/api/v1/favourites")
  80
  81     assert [status] = json_response(first_conn, 200)
  82     assert status["id"] == to_string(activity.id)
  83
  84     assert [{"link", _link_header}] =
  85              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
  86
  87     # Honours query params
  88     {:ok, second_activity} =
  89       CommonAPI.post(other_user, %{
  90         "status" =>
  91           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
  92       })
  93
  94     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
  95
  96     last_like = status["id"]
  97
  98     second_conn =
  99       conn
 100       |> assign(:user, user)
 101       |> get("/api/v1/favourites?since_id=#{last_like}")
 102
 103     assert [second_status] = json_response(second_conn, 200)
 104     assert second_status["id"] == to_string(second_activity.id)
 105
 106     third_conn =
 107       conn
 108       |> assign(:user, user)
 109       |> get("/api/v1/favourites?limit=0")
 110
 111     assert [] = json_response(third_conn, 200)
 112   end
 113
 114   describe "link headers" do
 115     test "preserves parameters in link headers", %{conn: conn} do
 116       user = insert(:user)
 117       other_user = insert(:user)
 118
 119       {:ok, activity1} =
 120         CommonAPI.post(other_user, %{
 121           "status" => "hi @#{user.nickname}",
 122           "visibility" => "public"
 123         })
 124
 125       {:ok, activity2} =
 126         CommonAPI.post(other_user, %{
 127           "status" => "hi @#{user.nickname}",
 128           "visibility" => "public"
 129         })
 130
 131       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
 132       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
 133
 134       conn =
 135         conn
 136         |> assign(:user, user)
 137         |> get("/api/v1/notifications", %{media_only: true})
 138
 139       assert [link_header] = get_resp_header(conn, "link")
 140       assert link_header =~ ~r/media_only=true/
 141       assert link_header =~ ~r/min_id=#{notification2.id}/
 142       assert link_header =~ ~r/max_id=#{notification1.id}/
 143     end
 144   end
 145
 146   describe "empty_array, stubs for mastodon api" do
 147     test "GET /api/v1/accounts/:id/identity_proofs", %{conn: conn} do
 148       user = insert(:user)
 149
 150       res =
 151         conn
 152         |> assign(:user, user)
 153         |> get("/api/v1/accounts/#{user.id}/identity_proofs")
 154         |> json_response(200)
 155
 156       assert res == []
 157     end
 158
 159     test "GET /api/v1/endorsements", %{conn: conn} do
 160       user = insert(:user)
 161
 162       res =
 163         conn
 164         |> assign(:user, user)
 165         |> get("/api/v1/endorsements")
 166         |> json_response(200)
 167
 168       assert res == []
 169     end
 170
 171     test "GET /api/v1/trends", %{conn: conn} do
 172       user = insert(:user)
 173
 174       res =
 175         conn
 176         |> assign(:user, user)
 177         |> get("/api/v1/trends")
 178         |> json_response(200)
 179
 180       assert res == []
 181     end
 182   end
 183 end