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 Ecto.Changeset
   9   alias Pleroma.Config
  10   alias Pleroma.Notification
  11   alias Pleroma.Repo
  12   alias Pleroma.User
  13   alias Pleroma.Web.CommonAPI
  14
  15   import Pleroma.Factory
  16   import Tesla.Mock
  17
  18   setup do
  19     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  20     :ok
  21   end
  22
  23   clear_config([:instance, :public])
  24   clear_config([:rich_media, :enabled])
  25
  26   test "getting a list of mutes", %{conn: conn} do
  27     user = insert(:user)
  28     other_user = insert(:user)
  29
  30     {:ok, user} = User.mute(user, other_user)
  31
  32     conn =
  33       conn
  34       |> assign(:user, user)
  35       |> get("/api/v1/mutes")
  36
  37     other_user_id = to_string(other_user.id)
  38     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
  39   end
  40
  41   test "getting a list of blocks", %{conn: conn} do
  42     user = insert(:user)
  43     other_user = insert(:user)
  44
  45     {:ok, user} = User.block(user, other_user)
  46
  47     conn =
  48       conn
  49       |> assign(:user, user)
  50       |> get("/api/v1/blocks")
  51
  52     other_user_id = to_string(other_user.id)
  53     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
  54   end
  55
  56   test "unimplemented follow_requests, blocks, domain blocks" do
  57     user = insert(:user)
  58
  59     ["blocks", "domain_blocks", "follow_requests"]
  60     |> Enum.each(fn endpoint ->
  61       conn =
  62         build_conn()
  63         |> assign(:user, user)
  64         |> get("/api/v1/#{endpoint}")
  65
  66       assert [] = json_response(conn, 200)
  67     end)
  68   end
  69
  70   test "returns the favorites of a user", %{conn: conn} do
  71     user = insert(:user)
  72     other_user = insert(:user)
  73
  74     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
  75     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
  76
  77     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
  78
  79     first_conn =
  80       conn
  81       |> assign(:user, user)
  82       |> get("/api/v1/favourites")
  83
  84     assert [status] = json_response(first_conn, 200)
  85     assert status["id"] == to_string(activity.id)
  86
  87     assert [{"link", _link_header}] =
  88              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
  89
  90     # Honours query params
  91     {:ok, second_activity} =
  92       CommonAPI.post(other_user, %{
  93         "status" =>
  94           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
  95       })
  96
  97     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
  98
  99     last_like = status["id"]
 100
 101     second_conn =
 102       conn
 103       |> assign(:user, user)
 104       |> get("/api/v1/favourites?since_id=#{last_like}")
 105
 106     assert [second_status] = json_response(second_conn, 200)
 107     assert second_status["id"] == to_string(second_activity.id)
 108
 109     third_conn =
 110       conn
 111       |> assign(:user, user)
 112       |> get("/api/v1/favourites?limit=0")
 113
 114     assert [] = json_response(third_conn, 200)
 115   end
 116
 117   test "get instance information", %{conn: conn} do
 118     conn = get(conn, "/api/v1/instance")
 119     assert result = json_response(conn, 200)
 120
 121     email = Config.get([:instance, :email])
 122     # Note: not checking for "max_toot_chars" since it's optional
 123     assert %{
 124              "uri" => _,
 125              "title" => _,
 126              "description" => _,
 127              "version" => _,
 128              "email" => from_config_email,
 129              "urls" => %{
 130                "streaming_api" => _
 131              },
 132              "stats" => _,
 133              "thumbnail" => _,
 134              "languages" => _,
 135              "registrations" => _,
 136              "poll_limits" => _
 137            } = result
 138
 139     assert email == from_config_email
 140   end
 141
 142   test "get instance stats", %{conn: conn} do
 143     user = insert(:user, %{local: true})
 144
 145     user2 = insert(:user, %{local: true})
 146     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
 147
 148     insert(:user, %{local: false, nickname: "u@peer1.com"})
 149     insert(:user, %{local: false, nickname: "u@peer2.com"})
 150
 151     {:ok, _} = CommonAPI.post(user, %{"status" => "cofe"})
 152
 153     # Stats should count users with missing or nil `info.deactivated` value
 154
 155     {:ok, _user} =
 156       user.id
 157       |> User.get_cached_by_id()
 158       |> User.update_info(&Changeset.change(&1, %{deactivated: nil}))
 159
 160     Pleroma.Stats.force_update()
 161
 162     conn = get(conn, "/api/v1/instance")
 163
 164     assert result = json_response(conn, 200)
 165
 166     stats = result["stats"]
 167
 168     assert stats
 169     assert stats["user_count"] == 1
 170     assert stats["status_count"] == 1
 171     assert stats["domain_count"] == 2
 172   end
 173
 174   test "get peers", %{conn: conn} do
 175     insert(:user, %{local: false, nickname: "u@peer1.com"})
 176     insert(:user, %{local: false, nickname: "u@peer2.com"})
 177
 178     Pleroma.Stats.force_update()
 179
 180     conn = get(conn, "/api/v1/instance/peers")
 181
 182     assert result = json_response(conn, 200)
 183
 184     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
 185   end
 186
 187   test "put settings", %{conn: conn} do
 188     user = insert(:user)
 189
 190     conn =
 191       conn
 192       |> assign(:user, user)
 193       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
 194
 195     assert _result = json_response(conn, 200)
 196
 197     user = User.get_cached_by_ap_id(user.ap_id)
 198     assert user.info.settings == %{"programming" => "socks"}
 199   end
 200
 201   describe "link headers" do
 202     test "preserves parameters in link headers", %{conn: conn} do
 203       user = insert(:user)
 204       other_user = insert(:user)
 205
 206       {:ok, activity1} =
 207         CommonAPI.post(other_user, %{
 208           "status" => "hi @#{user.nickname}",
 209           "visibility" => "public"
 210         })
 211
 212       {:ok, activity2} =
 213         CommonAPI.post(other_user, %{
 214           "status" => "hi @#{user.nickname}",
 215           "visibility" => "public"
 216         })
 217
 218       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
 219       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
 220
 221       conn =
 222         conn
 223         |> assign(:user, user)
 224         |> get("/api/v1/notifications", %{media_only: true})
 225
 226       assert [link_header] = get_resp_header(conn, "link")
 227       assert link_header =~ ~r/media_only=true/
 228       assert link_header =~ ~r/min_id=#{notification2.id}/
 229       assert link_header =~ ~r/max_id=#{notification1.id}/
 230     end
 231   end
 232
 233   describe "custom emoji" do
 234     test "with tags", %{conn: conn} do
 235       [emoji | _body] =
 236         conn
 237         |> get("/api/v1/custom_emojis")
 238         |> json_response(200)
 239
 240       assert Map.has_key?(emoji, "shortcode")
 241       assert Map.has_key?(emoji, "static_url")
 242       assert Map.has_key?(emoji, "tags")
 243       assert is_list(emoji["tags"])
 244       assert Map.has_key?(emoji, "category")
 245       assert Map.has_key?(emoji, "url")
 246       assert Map.has_key?(emoji, "visible_in_picker")
 247     end
 248   end
 249
 250   describe "index/2 redirections" do
 251     setup %{conn: conn} do
 252       session_opts = [
 253         store: :cookie,
 254         key: "_test",
 255         signing_salt: "cooldude"
 256       ]
 257
 258       conn =
 259         conn
 260         |> Plug.Session.call(Plug.Session.init(session_opts))
 261         |> fetch_session()
 262
 263       test_path = "/web/statuses/test"
 264       %{conn: conn, path: test_path}
 265     end
 266
 267     test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
 268       conn = get(conn, path)
 269
 270       assert conn.status == 302
 271       assert redirected_to(conn) == "/web/login"
 272     end
 273
 274     test "redirects not logged-in users to the login page on private instances", %{
 275       conn: conn,
 276       path: path
 277     } do
 278       Config.put([:instance, :public], false)
 279
 280       conn = get(conn, path)
 281
 282       assert conn.status == 302
 283       assert redirected_to(conn) == "/web/login"
 284     end
 285
 286     test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
 287       token = insert(:oauth_token)
 288
 289       conn =
 290         conn
 291         |> assign(:user, token.user)
 292         |> put_session(:oauth_token, token.token)
 293         |> get(path)
 294
 295       assert conn.status == 200
 296     end
 297
 298     test "saves referer path to session", %{conn: conn, path: path} do
 299       conn = get(conn, path)
 300       return_to = Plug.Conn.get_session(conn, :return_to)
 301
 302       assert return_to == path
 303     end
 304   end
 305
 306   describe "empty_array, stubs for mastodon api" do
 307     test "GET /api/v1/accounts/:id/identity_proofs", %{conn: conn} do
 308       user = insert(:user)
 309
 310       res =
 311         conn
 312         |> assign(:user, user)
 313         |> get("/api/v1/accounts/#{user.id}/identity_proofs")
 314         |> json_response(200)
 315
 316       assert res == []
 317     end
 318
 319     test "GET /api/v1/endorsements", %{conn: conn} do
 320       user = insert(:user)
 321
 322       res =
 323         conn
 324         |> assign(:user, user)
 325         |> get("/api/v1/endorsements")
 326         |> json_response(200)
 327
 328       assert res == []
 329     end
 330
 331     test "GET /api/v1/trends", %{conn: conn} do
 332       user = insert(:user)
 333
 334       res =
 335         conn
 336         |> assign(:user, user)
 337         |> get("/api/v1/trends")
 338         |> json_response(200)
 339
 340       assert res == []
 341     end
 342   end
 343 end