Add PleromaAPI.AccountController

lib/pleroma/web/controller_helper.ex

@@ -68,4 +68,11 @@ def add_link_headers(conn, activities, extra_params \\ %{}) do
         conn
     end
   end
+
+  def assign_account_by_id(%{params: %{"id" => id}} = conn, _) do
+    case Pleroma.User.get_cached_by_id(id) do
+      %Pleroma.User{} = account -> assign(conn, :account, account)
+      nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) |> halt()
+    end
+  end
 end

lib/pleroma/web/mastodon_api/controllers/account_controller.ex

@@ -5,7 +5,8 @@
 defmodule Pleroma.Web.MastodonAPI.AccountController do
   use Pleroma.Web, :controller
 
-  import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2, truthy_param?: 1]
+  import Pleroma.Web.ControllerHelper,
+    only: [add_link_headers: 2, truthy_param?: 1, assign_account_by_id: 2, json_response: 3]
 
   alias Pleroma.User
   alias Pleroma.Web.CommonAPI
@@ -15,13 +16,11 @@ defmodule Pleroma.Web.MastodonAPI.AccountController do
   alias Pleroma.Web.MastodonAPI.ListView
   alias Pleroma.Plugs.RateLimiter
 
-  require Pleroma.Constants
-
   @relations ~w(follow unfollow)a
 
   plug(RateLimiter, {:relations_id_action, params: ["id", "uri"]} when action in @relations)
   plug(RateLimiter, :relations_actions when action in @relations)
-  plug(:assign_account when action not in [:show, :statuses, :follows])
+  plug(:assign_account_by_id when action not in [:show, :statuses])
 
   action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
 
@@ -85,60 +84,6 @@ def lists(%{assigns: %{user: user, account: account}} = conn, _params) do
     |> render("index.json", lists: lists)
   end
 
-  @doc "GET /api/v1/pleroma/accounts/:id/favourites"
-  def favourites(%{assigns: %{account: %{info: %{hide_favorites: true}}}} = conn, _params) do
-    render_error(conn, :forbidden, "Can't get favorites")
-  end
-
-  def favourites(%{assigns: %{user: for_user, account: user}} = conn, params) do
-    params =
-      params
-      |> Map.put("type", "Create")
-      |> Map.put("favorited_by", user.ap_id)
-      |> Map.put("blocking_user", for_user)
-
-    recipients =
-      if for_user do
-        [Pleroma.Constants.as_public()] ++ [for_user.ap_id | for_user.following]
-      else
-        [Pleroma.Constants.as_public()]
-      end
-
-    activities =
-      recipients
-      |> ActivityPub.fetch_activities(params)
-      |> Enum.reverse()
-
-    conn
-    |> add_link_headers(activities)
-    |> put_view(StatusView)
-    |> render("index.json", activities: activities, for: for_user, as: :activity)
-  end
-
-  @doc "POST /api/v1/pleroma/accounts/:id/subscribe"
-  def subscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
-    with {:ok, subscription_target} <- User.subscribe(user, subscription_target) do
-      render(conn, "relationship.json", user: user, target: subscription_target)
-    else
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
-  @doc "POST /api/v1/pleroma/accounts/:id/unsubscribe"
-  def unsubscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
-    with {:ok, subscription_target} <- User.unsubscribe(user, subscription_target) do
-      render(conn, "relationship.json", user: user, target: subscription_target)
-    else
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
   @doc "POST /api/v1/accounts/:id/follow"
   def follow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
     {:error, :not_found}
@@ -148,14 +93,11 @@ def follow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
     with {:ok, follower} <- MastodonAPI.follow(follower, followed, conn.params) do
       render(conn, "relationship.json", user: follower, target: followed)
     else
-      {:error, message} ->
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
     end
   end
 
-  @doc "POST /api/v1/pleroma/:id/unfollow"
+  @doc "POST /api/v1/accounts/:id/unfollow"
   def unfollow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
     {:error, :not_found}
   end
@@ -173,10 +115,7 @@ def mute(%{assigns: %{user: muter, account: muted}} = conn, params) do
     with {:ok, muter} <- User.mute(muter, muted, notifications?) do
       render(conn, "relationship.json", user: muter, target: muted)
     else
-      {:error, message} ->
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
     end
   end
 
@@ -185,10 +124,7 @@ def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
     with {:ok, muter} <- User.unmute(muter, muted) do
       render(conn, "relationship.json", user: muter, target: muted)
     else
-      {:error, message} ->
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
     end
   end
 
@@ -198,10 +134,7 @@ def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
       render(conn, "relationship.json", user: blocker, target: blocked)
     else
-      {:error, message} ->
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
     end
   end
 
@@ -211,17 +144,7 @@ def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
       render(conn, "relationship.json", user: blocker, target: blocked)
     else
-      {:error, message} ->
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
-  defp assign_account(%{params: %{"id" => id}} = conn, _) do
-    case User.get_cached_by_id(id) do
-      %User{} = account -> assign(conn, :account, account)
-      nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) |> halt()
     end
   end
 end

lib/pleroma/web/mastodon_api/controllers/mastodon_api_controller.ex

@@ -5,10 +5,8 @@
 defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   use Pleroma.Web, :controller
 
-  import Pleroma.Web.ControllerHelper,
+  import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2, truthy_param?: 1]
-    only: [json_response: 3, add_link_headers: 2, truthy_param?: 1]
 
-  alias Ecto.Changeset
   alias Pleroma.Activity
   alias Pleroma.Bookmark
   alias Pleroma.Config
@@ -40,7 +38,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   plug(RateLimiter, :app_account_creation when action == :account_register)
   plug(RateLimiter, :search when action in [:search, :search2, :account_search])
   plug(RateLimiter, :password_reset when action == :password_reset)
-  plug(RateLimiter, :account_confirmation_resend when action == :account_confirmation_resend)
 
   @local_mastodon_name "Mastodon-Local"
 
@@ -167,61 +164,6 @@ def update_credentials(%{assigns: %{user: user}} = conn, params) do
     end
   end
 
-  def update_avatar(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
-    change = Changeset.change(user, %{avatar: nil})
-    {:ok, user} = User.update_and_set_cache(change)
-    CommonAPI.update(user)
-
-    json(conn, %{url: nil})
-  end
-
-  def update_avatar(%{assigns: %{user: user}} = conn, params) do
-    {:ok, object} = ActivityPub.upload(params, type: :avatar)
-    change = Changeset.change(user, %{avatar: object.data})
-    {:ok, user} = User.update_and_set_cache(change)
-    CommonAPI.update(user)
-    %{"url" => [%{"href" => href} | _]} = object.data
-
-    json(conn, %{url: href})
-  end
-
-  def update_banner(%{assigns: %{user: user}} = conn, %{"banner" => ""}) do
-    new_info = %{"banner" => %{}}
-
-    with {:ok, user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      CommonAPI.update(user)
-      json(conn, %{url: nil})
-    end
-  end
-
-  def update_banner(%{assigns: %{user: user}} = conn, params) do
-    with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, type: :banner),
-         new_info <- %{"banner" => object.data},
-         {:ok, user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      CommonAPI.update(user)
-      %{"url" => [%{"href" => href} | _]} = object.data
-
-      json(conn, %{url: href})
-    end
-  end
-
-  def update_background(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
-    new_info = %{"background" => %{}}
-
-    with {:ok, _user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      json(conn, %{url: nil})
-    end
-  end
-
-  def update_background(%{assigns: %{user: user}} = conn, params) do
-    with {:ok, object} <- ActivityPub.upload(params, type: :background),
-         new_info <- %{"background" => object.data},
-         {:ok, _user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      %{"url" => [%{"href" => href} | _]} = object.data
-
-      json(conn, %{url: href})
-    end
-  end
 
   def verify_credentials(%{assigns: %{user: user}} = conn, _) do
     chat_token = Phoenix.Token.sign(conn, "user socket", user.id)
@@ -236,7 +178,6 @@ def verify_credentials(%{assigns: %{user: user}} = conn, _) do
 
     json(conn, account)
   end
-
   def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
     with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
       conn
@@ -767,16 +708,6 @@ def password_reset(conn, params) do
     end
   end
 
-  def account_confirmation_resend(conn, params) do
-    nickname_or_email = params["email"] || params["nickname"]
-
-    with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
-         {:ok, _} <- User.try_send_confirmation_email(user) do
-      conn
-      |> json_response(:no_content, "")
-    end
-  end
-
   def try_render(conn, target, params)
       when is_binary(target) do
     case render(conn, target, params) do

lib/pleroma/web/pleroma_api/controllers/account_controller.ex

@@ -0,0 +1,143 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.PleromaAPI.AccountController do
+  use Pleroma.Web, :controller
+
+  import Pleroma.Web.ControllerHelper,
+    only: [json_response: 3, add_link_headers: 2, assign_account_by_id: 2]
+
+  alias Ecto.Changeset
+  alias Pleroma.Plugs.RateLimiter
+  alias Pleroma.User
+  alias Pleroma.Web.ActivityPub.ActivityPub
+  alias Pleroma.Web.CommonAPI
+  alias Pleroma.Web.MastodonAPI.StatusView
+
+  require Pleroma.Constants
+
+  plug(RateLimiter, :account_confirmation_resend when action == :confirmation_resend)
+  plug(:assign_account_by_id when action in [:favourites, :subscribe, :unsubscribe])
+  plug(:put_view, Pleroma.Web.MastodonAPI.AccountView)
+
+  @doc "POST /api/v1/pleroma/accounts/confirmation_resend"
+  def confirmation_resend(conn, params) do
+    nickname_or_email = params["email"] || params["nickname"]
+
+    with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
+         {:ok, _} <- User.try_send_confirmation_email(user) do
+      json_response(conn, :no_content, "")
+    end
+  end
+
+  @doc "PATCH /api/v1/pleroma/accounts/update_avatar"
+  def update_avatar(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
+    {:ok, user} =
+      user
+      |> Changeset.change(%{avatar: nil})
+      |> User.update_and_set_cache()
+
+    CommonAPI.update(user)
+
+    json(conn, %{url: nil})
+  end
+
+  def update_avatar(%{assigns: %{user: user}} = conn, params) do
+    {:ok, %{data: data}} = ActivityPub.upload(params, type: :avatar)
+    {:ok, user} = user |> Changeset.change(%{avatar: data}) |> User.update_and_set_cache()
+    %{"url" => [%{"href" => href} | _]} = data
+
+    CommonAPI.update(user)
+
+    json(conn, %{url: href})
+  end
+
+  @doc "PATCH /api/v1/pleroma/accounts/update_banner"
+  def update_banner(%{assigns: %{user: user}} = conn, %{"banner" => ""}) do
+    new_info = %{"banner" => %{}}
+
+    with {:ok, user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
+      CommonAPI.update(user)
+      json(conn, %{url: nil})
+    end
+  end
+
+  def update_banner(%{assigns: %{user: user}} = conn, params) do
+    with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, type: :banner),
+         new_info <- %{"banner" => object.data},
+         {:ok, user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
+      CommonAPI.update(user)
+      %{"url" => [%{"href" => href} | _]} = object.data
+
+      json(conn, %{url: href})
+    end
+  end
+
+  @doc "PATCH /api/v1/pleroma/accounts/update_background"
+  def update_background(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
+    new_info = %{"background" => %{}}
+
+    with {:ok, _user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
+      json(conn, %{url: nil})
+    end
+  end
+
+  def update_background(%{assigns: %{user: user}} = conn, params) do
+    with {:ok, object} <- ActivityPub.upload(params, type: :background),
+         new_info <- %{"background" => object.data},
+         {:ok, _user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
+      %{"url" => [%{"href" => href} | _]} = object.data
+
+      json(conn, %{url: href})
+    end
+  end
+
+  @doc "GET /api/v1/pleroma/accounts/:id/favourites"
+  def favourites(%{assigns: %{account: %{info: %{hide_favorites: true}}}} = conn, _params) do
+    render_error(conn, :forbidden, "Can't get favorites")
+  end
+
+  def favourites(%{assigns: %{user: for_user, account: user}} = conn, params) do
+    params =
+      params
+      |> Map.put("type", "Create")
+      |> Map.put("favorited_by", user.ap_id)
+      |> Map.put("blocking_user", for_user)
+
+    recipients =
+      if for_user do
+        [Pleroma.Constants.as_public()] ++ [for_user.ap_id | for_user.following]
+      else
+        [Pleroma.Constants.as_public()]
+      end
+
+    activities =
+      recipients
+      |> ActivityPub.fetch_activities(params)
+      |> Enum.reverse()
+
+    conn
+    |> add_link_headers(activities)
+    |> put_view(StatusView)
+    |> render("index.json", activities: activities, for: for_user, as: :activity)
+  end
+
+  @doc "POST /api/v1/pleroma/accounts/:id/subscribe"
+  def subscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
+    with {:ok, subscription_target} <- User.subscribe(user, subscription_target) do
+      render(conn, "relationship.json", user: user, target: subscription_target)
+    else
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
+    end
+  end
+
+  @doc "POST /api/v1/pleroma/accounts/:id/unsubscribe"
+  def unsubscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
+    with {:ok, subscription_target} <- User.unsubscribe(user, subscription_target) do
+      render(conn, "relationship.json", user: user, target: subscription_target)
+    else
+      {:error, message} -> json_response(conn, :forbidden, %{error: message})
+    end
+  end
+end

lib/pleroma/web/router.ex

@@ -287,24 +287,40 @@ defmodule Pleroma.Web.Router do
   end
 
   scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
-    pipe_through(:authenticated_api)
-
     scope [] do
+      pipe_through(:authenticated_api)
       pipe_through(:oauth_read)
       get("/conversations/:id/statuses", PleromaAPIController, :conversation_statuses)
       get("/conversations/:id", PleromaAPIController, :conversation)
     end
 
     scope [] do
+      pipe_through(:authenticated_api)
       pipe_through(:oauth_write)
       patch("/conversations/:id", PleromaAPIController, :update_conversation)
       post("/notifications/read", PleromaAPIController, :read_notification)
+
+      patch("/accounts/update_avatar", AccountController, :update_avatar)
+      patch("/accounts/update_banner", AccountController, :update_banner)
+      patch("/accounts/update_background", AccountController, :update_background)
+      post("/scrobble", ScrobbleController, :new_scrobble)
     end
 
     scope [] do
-      pipe_through(:oauth_write)
+      pipe_through(:api)
-      post("/scrobble", ScrobbleController, :new_scrobble)
+      pipe_through(:oauth_read_or_public)
+      get("/accounts/:id/favourites", AccountController, :favourites)
     end
+
+    scope [] do
+      pipe_through(:authenticated_api)
+      pipe_through(:oauth_follow)
+
+      post("/accounts/:id/subscribe", AccountController, :subscribe)
+      post("/accounts/:id/unsubscribe", AccountController, :unsubscribe)
+    end
+
+    post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
   end
 
   scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
@@ -400,10 +416,6 @@ defmodule Pleroma.Web.Router do
       put("/filters/:id", FilterController, :update)
       delete("/filters/:id", FilterController, :delete)
 
-      patch("/pleroma/accounts/update_avatar", MastodonAPIController, :update_avatar)
-      patch("/pleroma/accounts/update_banner", MastodonAPIController, :update_banner)
-      patch("/pleroma/accounts/update_background", MastodonAPIController, :update_background)
-
       get("/pleroma/mascot", MastodonAPIController, :get_mascot)
       put("/pleroma/mascot", MastodonAPIController, :set_mascot)
 
@@ -426,9 +438,6 @@ defmodule Pleroma.Web.Router do
 
       post("/domain_blocks", DomainBlockController, :create)
       delete("/domain_blocks", DomainBlockController, :delete)
-
-      post("/pleroma/accounts/:id/subscribe", AccountController, :subscribe)
-      post("/pleroma/accounts/:id/unsubscribe", AccountController, :unsubscribe)
     end
 
     scope [] do
@@ -467,12 +476,6 @@ defmodule Pleroma.Web.Router do
 
     get("/accounts/search", SearchController, :account_search)
 
-    post(
-      "/pleroma/accounts/confirmation_resend",
-      MastodonAPIController,
-      :account_confirmation_resend
-    )
-
     scope [] do
       pipe_through(:oauth_read_or_public)
 
@@ -492,8 +495,6 @@ defmodule Pleroma.Web.Router do
       get("/accounts/:id", AccountController, :show)
 
       get("/search", SearchController, :search)
-
-      get("/pleroma/accounts/:id/favourites", AccountController, :favourites)
     end
   end
 

test/web/mastodon_api/controllers/account_controller_test.exs

@@ -552,199 +552,6 @@ test "without notifications", %{conn: conn} do
     end
   end
 
-  describe "getting favorites timeline of specified user" do
-    setup do
-      [current_user, user] = insert_pair(:user, %{info: %{hide_favorites: false}})
-      [current_user: current_user, user: user]
-    end
-
-    test "returns list of statuses favorited by specified user", %{
-      conn: conn,
-      current_user: current_user,
-      user: user
-    } do
-      [activity | _] = insert_pair(:note_activity)
-      CommonAPI.favorite(activity.id, user)
-
-      response =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response(:ok)
-
-      [like] = response
-
-      assert length(response) == 1
-      assert like["id"] == activity.id
-    end
-
-    test "returns favorites for specified user_id when user is not logged in", %{
-      conn: conn,
-      user: user
-    } do
-      activity = insert(:note_activity)
-      CommonAPI.favorite(activity.id, user)
-
-      response =
-        conn
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response(:ok)
-
-      assert length(response) == 1
-    end
-
-    test "returns favorited DM only when user is logged in and he is one of recipients", %{
-      conn: conn,
-      current_user: current_user,
-      user: user
-    } do
-      {:ok, direct} =
-        CommonAPI.post(current_user, %{
-          "status" => "Hi @#{user.nickname}!",
-          "visibility" => "direct"
-        })
-
-      CommonAPI.favorite(direct.id, user)
-
-      response =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response(:ok)
-
-      assert length(response) == 1
-
-      anonymous_response =
-        conn
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response(:ok)
-
-      assert Enum.empty?(anonymous_response)
-    end
-
-    test "does not return others' favorited DM when user is not one of recipients", %{
-      conn: conn,
-      current_user: current_user,
-      user: user
-    } do
-      user_two = insert(:user)
-
-      {:ok, direct} =
-        CommonAPI.post(user_two, %{
-          "status" => "Hi @#{user.nickname}!",
-          "visibility" => "direct"
-        })
-
-      CommonAPI.favorite(direct.id, user)
-
-      response =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response(:ok)
-
-      assert Enum.empty?(response)
-    end
-
-    test "paginates favorites using since_id and max_id", %{
-      conn: conn,
-      current_user: current_user,
-      user: user
-    } do
-      activities = insert_list(10, :note_activity)
-
-      Enum.each(activities, fn activity ->
-        CommonAPI.favorite(activity.id, user)
-      end)
-
-      third_activity = Enum.at(activities, 2)
-      seventh_activity = Enum.at(activities, 6)
-
-      response =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
-          since_id: third_activity.id,
-          max_id: seventh_activity.id
-        })
-        |> json_response(:ok)
-
-      assert length(response) == 3
-      refute third_activity in response
-      refute seventh_activity in response
-    end
-
-    test "limits favorites using limit parameter", %{
-      conn: conn,
-      current_user: current_user,
-      user: user
-    } do
-      7
-      |> insert_list(:note_activity)
-      |> Enum.each(fn activity ->
-        CommonAPI.favorite(activity.id, user)
-      end)
-
-      response =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
-        |> json_response(:ok)
-
-      assert length(response) == 3
-    end
-
-    test "returns empty response when user does not have any favorited statuses", %{
-      conn: conn,
-      current_user: current_user,
-      user: user
-    } do
-      response =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response(:ok)
-
-      assert Enum.empty?(response)
-    end
-
-    test "returns 404 error when specified user is not exist", %{conn: conn} do
-      conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")
-
-      assert json_response(conn, 404) == %{"error" => "Record not found"}
-    end
-
-    test "returns 403 error when user has hidden own favorites", %{
-      conn: conn,
-      current_user: current_user
-    } do
-      user = insert(:user, %{info: %{hide_favorites: true}})
-      activity = insert(:note_activity)
-      CommonAPI.favorite(activity.id, user)
-
-      conn =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-
-      assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
-    end
-
-    test "hides favorites for new users by default", %{conn: conn, current_user: current_user} do
-      user = insert(:user)
-      activity = insert(:note_activity)
-      CommonAPI.favorite(activity.id, user)
-
-      conn =
-        conn
-        |> assign(:user, current_user)
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-
-      assert user.info.hide_favorites
-      assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
-    end
-  end
-
   describe "pinned statuses" do
     setup do
       user = insert(:user)
@@ -768,25 +575,6 @@ test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
     end
   end
 
-  test "subscribing / unsubscribing to a user", %{conn: conn} do
-    user = insert(:user)
-    subscription_target = insert(:user)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
-
-    assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
-
-    conn =
-      build_conn()
-      |> assign(:user, user)
-      |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
-
-    assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
-  end
-
   test "blocking / unblocking a user", %{conn: conn} do
     user = insert(:user)
     other_user = insert(:user)

test/web/mastodon_api/mastodon_api_controller_test.exs

@@ -23,8 +23,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   import Swoosh.TestAssertions
   import Tesla.Mock
 
-  @image "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
-
   setup do
     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
     :ok
@@ -80,101 +78,6 @@ test "apps/verify_credentials", %{conn: conn} do
     assert expected == json_response(conn, 200)
   end
 
-  test "user avatar can be set", %{conn: conn} do
-    user = insert(:user)
-    avatar_image = File.read!("test/fixtures/avatar_data_uri")
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> patch("/api/v1/pleroma/accounts/update_avatar", %{img: avatar_image})
-
-    user = refresh_record(user)
-
-    assert %{
-             "name" => _,
-             "type" => _,
-             "url" => [
-               %{
-                 "href" => _,
-                 "mediaType" => _,
-                 "type" => _
-               }
-             ]
-           } = user.avatar
-
-    assert %{"url" => _} = json_response(conn, 200)
-  end
-
-  test "user avatar can be reset", %{conn: conn} do
-    user = insert(:user)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> patch("/api/v1/pleroma/accounts/update_avatar", %{img: ""})
-
-    user = User.get_cached_by_id(user.id)
-
-    assert user.avatar == nil
-
-    assert %{"url" => nil} = json_response(conn, 200)
-  end
-
-  test "can set profile banner", %{conn: conn} do
-    user = insert(:user)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => @image})
-
-    user = refresh_record(user)
-    assert user.info.banner["type"] == "Image"
-
-    assert %{"url" => _} = json_response(conn, 200)
-  end
-
-  test "can reset profile banner", %{conn: conn} do
-    user = insert(:user)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => ""})
-
-    user = refresh_record(user)
-    assert user.info.banner == %{}
-
-    assert %{"url" => nil} = json_response(conn, 200)
-  end
-
-  test "background image can be set", %{conn: conn} do
-    user = insert(:user)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> patch("/api/v1/pleroma/accounts/update_background", %{"img" => @image})
-
-    user = refresh_record(user)
-    assert user.info.background["type"] == "Image"
-    assert %{"url" => _} = json_response(conn, 200)
-  end
-
-  test "background image can be reset", %{conn: conn} do
-    user = insert(:user)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> patch("/api/v1/pleroma/accounts/update_background", %{"img" => ""})
-
-    user = refresh_record(user)
-    assert user.info.background == %{}
-    assert %{"url" => nil} = json_response(conn, 200)
-  end
-
   test "creates an oauth app", %{conn: conn} do
     user = insert(:user)
     app_attrs = build(:oauth_app)
@@ -348,52 +251,6 @@ test "mascot retrieving", %{conn: conn} do
       assert url =~ "an_image"
     end
   end
-  describe "subscribing / unsubscribing" do
-    test "subscribing / unsubscribing to a user", %{conn: conn} do
-      user = insert(:user)
-      subscription_target = insert(:user)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
-
-      assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
-
-      conn =
-        build_conn()
-        |> assign(:user, user)
-        |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
-
-      assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
-    end
-  end
-
-  describe "subscribing" do
-    test "returns 404 when subscription_target not found", %{conn: conn} do
-      user = insert(:user)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/pleroma/accounts/target_id/subscribe")
-
-      assert %{"error" => "Record not found"} = json_response(conn, 404)
-    end
-  end
-
-  describe "unsubscribing" do
-    test "returns 404 when subscription_target not found", %{conn: conn} do
-      user = insert(:user)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/pleroma/accounts/target_id/unsubscribe")
-
-      assert %{"error" => "Record not found"} = json_response(conn, 404)
-    end
-  end
 
   test "getting a list of mutes", %{conn: conn} do
     user = insert(:user)
@@ -1088,42 +945,6 @@ test "it returns 400 when user is not local", %{conn: conn, user: user} do
     end
   end
 
-  describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
-    setup do
-      {:ok, user} =
-        insert(:user)
-        |> User.change_info(&User.Info.confirmation_changeset(&1, need_confirmation: true))
-        |> Repo.update()
-
-      assert user.info.confirmation_pending
-
-      [user: user]
-    end
-
-    clear_config([:instance, :account_activation_required]) do
-      Config.put([:instance, :account_activation_required], true)
-    end
-
-    test "resend account confirmation email", %{conn: conn, user: user} do
-      conn
-      |> assign(:user, user)
-      |> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
-      |> json_response(:no_content)
-
-      ObanHelpers.perform_all()
-
-      email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
-      notify_email = Config.get([:instance, :notify_email])
-      instance_name = Config.get([:instance, :name])
-
-      assert_email_sent(
-        from: {instance_name, notify_email},
-        to: {user.name, user.email},
-        html_body: email.html_body
-      )
-    end
-  end
-
   describe "GET /api/v1/suggestions" do
     setup do
       user = insert(:user)

test/web/pleroma_api/controllers/account_controller_test.exs

@@ -0,0 +1,395 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.PleromaAPI.AccountControllerTest do
+  use Pleroma.Web.ConnCase
+
+  alias Pleroma.Config
+  alias Pleroma.Repo
+  alias Pleroma.Tests.ObanHelpers
+  alias Pleroma.User
+  alias Pleroma.Web.CommonAPI
+
+  import Pleroma.Factory
+  import Swoosh.TestAssertions
+
+  @image "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
+
+  describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
+    setup do
+      {:ok, user} =
+        insert(:user)
+        |> User.change_info(&User.Info.confirmation_changeset(&1, need_confirmation: true))
+        |> Repo.update()
+
+      assert user.info.confirmation_pending
+
+      [user: user]
+    end
+
+    clear_config([:instance, :account_activation_required]) do
+      Config.put([:instance, :account_activation_required], true)
+    end
+
+    test "resend account confirmation email", %{conn: conn, user: user} do
+      conn
+      |> assign(:user, user)
+      |> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
+      |> json_response(:no_content)
+
+      ObanHelpers.perform_all()
+
+      email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
+      notify_email = Config.get([:instance, :notify_email])
+      instance_name = Config.get([:instance, :name])
+
+      assert_email_sent(
+        from: {instance_name, notify_email},
+        to: {user.name, user.email},
+        html_body: email.html_body
+      )
+    end
+  end
+
+  describe "PATCH /api/v1/pleroma/accounts/update_avatar" do
+    test "user avatar can be set", %{conn: conn} do
+      user = insert(:user)
+      avatar_image = File.read!("test/fixtures/avatar_data_uri")
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> patch("/api/v1/pleroma/accounts/update_avatar", %{img: avatar_image})
+
+      user = refresh_record(user)
+
+      assert %{
+               "name" => _,
+               "type" => _,
+               "url" => [
+                 %{
+                   "href" => _,
+                   "mediaType" => _,
+                   "type" => _
+                 }
+               ]
+             } = user.avatar
+
+      assert %{"url" => _} = json_response(conn, 200)
+    end
+
+    test "user avatar can be reset", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> patch("/api/v1/pleroma/accounts/update_avatar", %{img: ""})
+
+      user = User.get_cached_by_id(user.id)
+
+      assert user.avatar == nil
+
+      assert %{"url" => nil} = json_response(conn, 200)
+    end
+  end
+
+  describe "PATCH /api/v1/pleroma/accounts/update_banner" do
+    test "can set profile banner", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => @image})
+
+      user = refresh_record(user)
+      assert user.info.banner["type"] == "Image"
+
+      assert %{"url" => _} = json_response(conn, 200)
+    end
+
+    test "can reset profile banner", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => ""})
+
+      user = refresh_record(user)
+      assert user.info.banner == %{}
+
+      assert %{"url" => nil} = json_response(conn, 200)
+    end
+  end
+
+  describe "PATCH /api/v1/pleroma/accounts/update_background" do
+    test "background image can be set", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> patch("/api/v1/pleroma/accounts/update_background", %{"img" => @image})
+
+      user = refresh_record(user)
+      assert user.info.background["type"] == "Image"
+      assert %{"url" => _} = json_response(conn, 200)
+    end
+
+    test "background image can be reset", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> patch("/api/v1/pleroma/accounts/update_background", %{"img" => ""})
+
+      user = refresh_record(user)
+      assert user.info.background == %{}
+      assert %{"url" => nil} = json_response(conn, 200)
+    end
+  end
+
+  describe "getting favorites timeline of specified user" do
+    setup do
+      [current_user, user] = insert_pair(:user, %{info: %{hide_favorites: false}})
+      [current_user: current_user, user: user]
+    end
+
+    test "returns list of statuses favorited by specified user", %{
+      conn: conn,
+      current_user: current_user,
+      user: user
+    } do
+      [activity | _] = insert_pair(:note_activity)
+      CommonAPI.favorite(activity.id, user)
+
+      response =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+        |> json_response(:ok)
+
+      [like] = response
+
+      assert length(response) == 1
+      assert like["id"] == activity.id
+    end
+
+    test "returns favorites for specified user_id when user is not logged in", %{
+      conn: conn,
+      user: user
+    } do
+      activity = insert(:note_activity)
+      CommonAPI.favorite(activity.id, user)
+
+      response =
+        conn
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+        |> json_response(:ok)
+
+      assert length(response) == 1
+    end
+
+    test "returns favorited DM only when user is logged in and he is one of recipients", %{
+      conn: conn,
+      current_user: current_user,
+      user: user
+    } do
+      {:ok, direct} =
+        CommonAPI.post(current_user, %{
+          "status" => "Hi @#{user.nickname}!",
+          "visibility" => "direct"
+        })
+
+      CommonAPI.favorite(direct.id, user)
+
+      response =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+        |> json_response(:ok)
+
+      assert length(response) == 1
+
+      anonymous_response =
+        conn
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+        |> json_response(:ok)
+
+      assert Enum.empty?(anonymous_response)
+    end
+
+    test "does not return others' favorited DM when user is not one of recipients", %{
+      conn: conn,
+      current_user: current_user,
+      user: user
+    } do
+      user_two = insert(:user)
+
+      {:ok, direct} =
+        CommonAPI.post(user_two, %{
+          "status" => "Hi @#{user.nickname}!",
+          "visibility" => "direct"
+        })
+
+      CommonAPI.favorite(direct.id, user)
+
+      response =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+        |> json_response(:ok)
+
+      assert Enum.empty?(response)
+    end
+
+    test "paginates favorites using since_id and max_id", %{
+      conn: conn,
+      current_user: current_user,
+      user: user
+    } do
+      activities = insert_list(10, :note_activity)
+
+      Enum.each(activities, fn activity ->
+        CommonAPI.favorite(activity.id, user)
+      end)
+
+      third_activity = Enum.at(activities, 2)
+      seventh_activity = Enum.at(activities, 6)
+
+      response =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
+          since_id: third_activity.id,
+          max_id: seventh_activity.id
+        })
+        |> json_response(:ok)
+
+      assert length(response) == 3
+      refute third_activity in response
+      refute seventh_activity in response
+    end
+
+    test "limits favorites using limit parameter", %{
+      conn: conn,
+      current_user: current_user,
+      user: user
+    } do
+      7
+      |> insert_list(:note_activity)
+      |> Enum.each(fn activity ->
+        CommonAPI.favorite(activity.id, user)
+      end)
+
+      response =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
+        |> json_response(:ok)
+
+      assert length(response) == 3
+    end
+
+    test "returns empty response when user does not have any favorited statuses", %{
+      conn: conn,
+      current_user: current_user,
+      user: user
+    } do
+      response =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+        |> json_response(:ok)
+
+      assert Enum.empty?(response)
+    end
+
+    test "returns 404 error when specified user is not exist", %{conn: conn} do
+      conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")
+
+      assert json_response(conn, 404) == %{"error" => "Record not found"}
+    end
+
+    test "returns 403 error when user has hidden own favorites", %{
+      conn: conn,
+      current_user: current_user
+    } do
+      user = insert(:user, %{info: %{hide_favorites: true}})
+      activity = insert(:note_activity)
+      CommonAPI.favorite(activity.id, user)
+
+      conn =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+
+      assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
+    end
+
+    test "hides favorites for new users by default", %{conn: conn, current_user: current_user} do
+      user = insert(:user)
+      activity = insert(:note_activity)
+      CommonAPI.favorite(activity.id, user)
+
+      conn =
+        conn
+        |> assign(:user, current_user)
+        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
+
+      assert user.info.hide_favorites
+      assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
+    end
+  end
+
+  describe "subscribing / unsubscribing" do
+    test "subscribing / unsubscribing to a user", %{conn: conn} do
+      user = insert(:user)
+      subscription_target = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
+
+      assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
+
+      conn =
+        build_conn()
+        |> assign(:user, user)
+        |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
+
+      assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
+    end
+  end
+
+  describe "subscribing" do
+    test "returns 404 when subscription_target not found", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/pleroma/accounts/target_id/subscribe")
+
+      assert %{"error" => "Record not found"} = json_response(conn, 404)
+    end
+  end
+
+  describe "unsubscribing" do
+    test "returns 404 when subscription_target not found", %{conn: conn} do
+      user = insert(:user)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/pleroma/accounts/target_id/unsubscribe")
+
+      assert %{"error" => "Record not found"} = json_response(conn, 404)
+    end
+  end
+end

test/web/pleroma_api/controllers/emoji_api_controller_test.exs

@@ -1,3 +1,7 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
 defmodule Pleroma.Web.PleromaAPI.EmojiAPIControllerTest do
   use Pleroma.Web.ConnCase