Merge branch 'release/2.2.0' into 'stable'v2.2.0

Release/2.2.0

See merge request pleroma/secteam/pleroma!19

9 files changed, 0 insertions, 2281 deletions

diff --git a/test/web/pleroma_api/controllers/account_controller_test.exs b/test/web/pleroma_api/controllers/account_controller_test.exs
deleted file mode 100644
index 07909d48b..000000000
--- a/test/web/pleroma_api/controllers/account_controller_test.exs
+++ /dev/null
@@ -1,284 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 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.Tests.ObanHelpers
-  alias Pleroma.User
-  alias Pleroma.Web.CommonAPI
-
-  import Pleroma.Factory
-  import Swoosh.TestAssertions
-
-  describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
-    setup do
-      {:ok, user} =
-        insert(:user)
-        |> User.confirmation_changeset(need_confirmation: true)
-        |> User.update_and_set_cache()
-
-      assert user.confirmation_pending
-
-      [user: user]
-    end
-
-    setup do: clear_config([:instance, :account_activation_required], true)
-
-    test "resend account confirmation email", %{conn: conn, user: user} do
-      conn
-      |> put_req_header("content-type", "application/json")
-      |> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
-      |> json_response_and_validate_schema(: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
-
-    test "resend account confirmation email (with nickname)", %{conn: conn, user: user} do
-      conn
-      |> put_req_header("content-type", "application/json")
-      |> post("/api/v1/pleroma/accounts/confirmation_resend?nickname=#{user.nickname}")
-      |> json_response_and_validate_schema(: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 "getting favorites timeline of specified user" do
-    setup do
-      [current_user, user] = insert_pair(:user, hide_favorites: false)
-      %{user: current_user, conn: conn} = oauth_access(["read:favourites"], user: current_user)
-      [current_user: current_user, user: user, conn: conn]
-    end
-
-    test "returns list of statuses favorited by specified user", %{
-      conn: conn,
-      user: user
-    } do
-      [activity | _] = insert_pair(:note_activity)
-      CommonAPI.favorite(user, activity.id)
-
-      response =
-        conn
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response_and_validate_schema(:ok)
-
-      [like] = response
-
-      assert length(response) == 1
-      assert like["id"] == activity.id
-    end
-
-    test "returns favorites for specified user_id when requester is not logged in", %{
-      user: user
-    } do
-      activity = insert(:note_activity)
-      CommonAPI.favorite(user, activity.id)
-
-      response =
-        build_conn()
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response_and_validate_schema(200)
-
-      assert length(response) == 1
-    end
-
-    test "returns favorited DM only when user is logged in and he is one of recipients", %{
-      current_user: current_user,
-      user: user
-    } do
-      {:ok, direct} =
-        CommonAPI.post(current_user, %{
-          status: "Hi @#{user.nickname}!",
-          visibility: "direct"
-        })
-
-      CommonAPI.favorite(user, direct.id)
-
-      for u <- [user, current_user] do
-        response =
-          build_conn()
-          |> assign(:user, u)
-          |> assign(:token, insert(:oauth_token, user: u, scopes: ["read:favourites"]))
-          |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-          |> json_response_and_validate_schema(:ok)
-
-        assert length(response) == 1
-      end
-
-      response =
-        build_conn()
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response_and_validate_schema(200)
-
-      assert length(response) == 0
-    end
-
-    test "does not return others' favorited DM when user is not one of recipients", %{
-      conn: conn,
-      user: user
-    } do
-      user_two = insert(:user)
-
-      {:ok, direct} =
-        CommonAPI.post(user_two, %{
-          status: "Hi @#{user.nickname}!",
-          visibility: "direct"
-        })
-
-      CommonAPI.favorite(user, direct.id)
-
-      response =
-        conn
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response_and_validate_schema(:ok)
-
-      assert Enum.empty?(response)
-    end
-
-    test "paginates favorites using since_id and max_id", %{
-      conn: conn,
-      user: user
-    } do
-      activities = insert_list(10, :note_activity)
-
-      Enum.each(activities, fn activity ->
-        CommonAPI.favorite(user, activity.id)
-      end)
-
-      third_activity = Enum.at(activities, 2)
-      seventh_activity = Enum.at(activities, 6)
-
-      response =
-        conn
-        |> get(
-          "/api/v1/pleroma/accounts/#{user.id}/favourites?since_id=#{third_activity.id}&max_id=#{
-            seventh_activity.id
-          }"
-        )
-        |> json_response_and_validate_schema(:ok)
-
-      assert length(response) == 3
-      refute third_activity in response
-      refute seventh_activity in response
-    end
-
-    test "limits favorites using limit parameter", %{
-      conn: conn,
-      user: user
-    } do
-      7
-      |> insert_list(:note_activity)
-      |> Enum.each(fn activity ->
-        CommonAPI.favorite(user, activity.id)
-      end)
-
-      response =
-        conn
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites?limit=3")
-        |> json_response_and_validate_schema(:ok)
-
-      assert length(response) == 3
-    end
-
-    test "returns empty response when user does not have any favorited statuses", %{
-      conn: conn,
-      user: user
-    } do
-      response =
-        conn
-        |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
-        |> json_response_and_validate_schema(: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_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
-    end
-
-    test "returns 403 error when user has hidden own favorites", %{conn: conn} do
-      user = insert(:user, hide_favorites: true)
-      activity = insert(:note_activity)
-      CommonAPI.favorite(user, activity.id)
-
-      conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")
-
-      assert json_response_and_validate_schema(conn, 403) == %{"error" => "Can't get favorites"}
-    end
-
-    test "hides favorites for new users by default", %{conn: conn} do
-      user = insert(:user)
-      activity = insert(:note_activity)
-      CommonAPI.favorite(user, activity.id)
-
-      assert user.hide_favorites
-      conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")
-
-      assert json_response_and_validate_schema(conn, 403) == %{"error" => "Can't get favorites"}
-    end
-  end
-
-  describe "subscribing / unsubscribing" do
-    test "subscribing / unsubscribing to a user" do
-      %{user: user, conn: conn} = oauth_access(["follow"])
-      subscription_target = insert(:user)
-
-      ret_conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
-
-      assert %{"id" => _id, "subscribing" => true} =
-               json_response_and_validate_schema(ret_conn, 200)
-
-      conn = post(conn, "/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
-
-      assert %{"id" => _id, "subscribing" => false} = json_response_and_validate_schema(conn, 200)
-    end
-  end
-
-  describe "subscribing" do
-    test "returns 404 when subscription_target not found" do
-      %{conn: conn} = oauth_access(["write:follows"])
-
-      conn = post(conn, "/api/v1/pleroma/accounts/target_id/subscribe")
-
-      assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
-    end
-  end
-
-  describe "unsubscribing" do
-    test "returns 404 when subscription_target not found" do
-      %{conn: conn} = oauth_access(["follow"])
-
-      conn = post(conn, "/api/v1/pleroma/accounts/target_id/unsubscribe")
-
-      assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
-    end
-  end
-end
diff --git a/test/web/pleroma_api/controllers/chat_controller_test.exs b/test/web/pleroma_api/controllers/chat_controller_test.exs
deleted file mode 100644
index 44a78a738..000000000
--- a/test/web/pleroma_api/controllers/chat_controller_test.exs
+++ /dev/null
@@ -1,390 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-defmodule Pleroma.Web.PleromaAPI.ChatControllerTest do
-  use Pleroma.Web.ConnCase, async: true
-
-  alias Pleroma.Chat
-  alias Pleroma.Chat.MessageReference
-  alias Pleroma.Object
-  alias Pleroma.User
-  alias Pleroma.Web.ActivityPub.ActivityPub
-  alias Pleroma.Web.CommonAPI
-
-  import Pleroma.Factory
-
-  describe "POST /api/v1/pleroma/chats/:id/messages/:message_id/read" do
-    setup do: oauth_access(["write:chats"])
-
-    test "it marks one message as read", %{conn: conn, user: user} do
-      other_user = insert(:user)
-
-      {:ok, create} = CommonAPI.post_chat_message(other_user, user, "sup")
-      {:ok, _create} = CommonAPI.post_chat_message(other_user, user, "sup part 2")
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-      object = Object.normalize(create, false)
-      cm_ref = MessageReference.for_chat_and_object(chat, object)
-
-      assert cm_ref.unread == true
-
-      result =
-        conn
-        |> post("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}/read")
-        |> json_response_and_validate_schema(200)
-
-      assert result["unread"] == false
-
-      cm_ref = MessageReference.for_chat_and_object(chat, object)
-
-      assert cm_ref.unread == false
-    end
-  end
-
-  describe "POST /api/v1/pleroma/chats/:id/read" do
-    setup do: oauth_access(["write:chats"])
-
-    test "given a `last_read_id`, it marks everything until then as read", %{
-      conn: conn,
-      user: user
-    } do
-      other_user = insert(:user)
-
-      {:ok, create} = CommonAPI.post_chat_message(other_user, user, "sup")
-      {:ok, _create} = CommonAPI.post_chat_message(other_user, user, "sup part 2")
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-      object = Object.normalize(create, false)
-      cm_ref = MessageReference.for_chat_and_object(chat, object)
-
-      assert cm_ref.unread == true
-
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/chats/#{chat.id}/read", %{"last_read_id" => cm_ref.id})
-        |> json_response_and_validate_schema(200)
-
-      assert result["unread"] == 1
-
-      cm_ref = MessageReference.for_chat_and_object(chat, object)
-
-      assert cm_ref.unread == false
-    end
-  end
-
-  describe "POST /api/v1/pleroma/chats/:id/messages" do
-    setup do: oauth_access(["write:chats"])
-
-    test "it posts a message to the chat", %{conn: conn, user: user} do
-      other_user = insert(:user)
-
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "Hallo!!"})
-        |> json_response_and_validate_schema(200)
-
-      assert result["content"] == "Hallo!!"
-      assert result["chat_id"] == chat.id |> to_string()
-    end
-
-    test "it fails if there is no content", %{conn: conn, user: user} do
-      other_user = insert(:user)
-
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/chats/#{chat.id}/messages")
-        |> json_response_and_validate_schema(400)
-
-      assert %{"error" => "no_content"} == result
-    end
-
-    test "it works with an attachment", %{conn: conn, user: user} do
-      file = %Plug.Upload{
-        content_type: "image/jpg",
-        path: Path.absname("test/fixtures/image.jpg"),
-        filename: "an_image.jpg"
-      }
-
-      {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
-
-      other_user = insert(:user)
-
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{
-          "media_id" => to_string(upload.id)
-        })
-        |> json_response_and_validate_schema(200)
-
-      assert result["attachment"]
-    end
-
-    test "gets MRF reason when rejected", %{conn: conn, user: user} do
-      clear_config([:mrf_keyword, :reject], ["GNO"])
-      clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
-
-      other_user = insert(:user)
-
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "GNO/Linux"})
-        |> json_response_and_validate_schema(422)
-
-      assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} == result
-    end
-  end
-
-  describe "DELETE /api/v1/pleroma/chats/:id/messages/:message_id" do
-    setup do: oauth_access(["write:chats"])
-
-    test "it deletes a message from the chat", %{conn: conn, user: user} do
-      recipient = insert(:user)
-
-      {:ok, message} =
-        CommonAPI.post_chat_message(user, recipient, "Hello darkness my old friend")
-
-      {:ok, other_message} = CommonAPI.post_chat_message(recipient, user, "nico nico ni")
-
-      object = Object.normalize(message, false)
-
-      chat = Chat.get(user.id, recipient.ap_id)
-
-      cm_ref = MessageReference.for_chat_and_object(chat, object)
-
-      # Deleting your own message removes the message and the reference
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
-        |> json_response_and_validate_schema(200)
-
-      assert result["id"] == cm_ref.id
-      refute MessageReference.get_by_id(cm_ref.id)
-      assert %{data: %{"type" => "Tombstone"}} = Object.get_by_id(object.id)
-
-      # Deleting other people's messages just removes the reference
-      object = Object.normalize(other_message, false)
-      cm_ref = MessageReference.for_chat_and_object(chat, object)
-
-      result =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
-        |> json_response_and_validate_schema(200)
-
-      assert result["id"] == cm_ref.id
-      refute MessageReference.get_by_id(cm_ref.id)
-      assert Object.get_by_id(object.id)
-    end
-  end
-
-  describe "GET /api/v1/pleroma/chats/:id/messages" do
-    setup do: oauth_access(["read:chats"])
-
-    test "it paginates", %{conn: conn, user: user} do
-      recipient = insert(:user)
-
-      Enum.each(1..30, fn _ ->
-        {:ok, _} = CommonAPI.post_chat_message(user, recipient, "hey")
-      end)
-
-      chat = Chat.get(user.id, recipient.ap_id)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats/#{chat.id}/messages")
-        |> json_response_and_validate_schema(200)
-
-      assert length(result) == 20
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")
-        |> json_response_and_validate_schema(200)
-
-      assert length(result) == 10
-    end
-
-    test "it returns the messages for a given chat", %{conn: conn, user: user} do
-      other_user = insert(:user)
-      third_user = insert(:user)
-
-      {:ok, _} = CommonAPI.post_chat_message(user, other_user, "hey")
-      {:ok, _} = CommonAPI.post_chat_message(user, third_user, "hey")
-      {:ok, _} = CommonAPI.post_chat_message(user, other_user, "how are you?")
-      {:ok, _} = CommonAPI.post_chat_message(other_user, user, "fine, how about you?")
-
-      chat = Chat.get(user.id, other_user.ap_id)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats/#{chat.id}/messages")
-        |> json_response_and_validate_schema(200)
-
-      result
-      |> Enum.each(fn message ->
-        assert message["chat_id"] == chat.id |> to_string()
-      end)
-
-      assert length(result) == 3
-
-      # Trying to get the chat of a different user
-      result =
-        conn
-        |> assign(:user, other_user)
-        |> get("/api/v1/pleroma/chats/#{chat.id}/messages")
-
-      assert result |> json_response(404)
-    end
-  end
-
-  describe "POST /api/v1/pleroma/chats/by-account-id/:id" do
-    setup do: oauth_access(["write:chats"])
-
-    test "it creates or returns a chat", %{conn: conn} do
-      other_user = insert(:user)
-
-      result =
-        conn
-        |> post("/api/v1/pleroma/chats/by-account-id/#{other_user.id}")
-        |> json_response_and_validate_schema(200)
-
-      assert result["id"]
-    end
-  end
-
-  describe "GET /api/v1/pleroma/chats/:id" do
-    setup do: oauth_access(["read:chats"])
-
-    test "it returns a chat", %{conn: conn, user: user} do
-      other_user = insert(:user)
-
-      {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats/#{chat.id}")
-        |> json_response_and_validate_schema(200)
-
-      assert result["id"] == to_string(chat.id)
-    end
-  end
-
-  describe "GET /api/v1/pleroma/chats" do
-    setup do: oauth_access(["read:chats"])
-
-    test "it does not return chats with deleted users", %{conn: conn, user: user} do
-      recipient = insert(:user)
-      {:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
-
-      Pleroma.Repo.delete(recipient)
-      User.invalidate_cache(recipient)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats")
-        |> json_response_and_validate_schema(200)
-
-      assert length(result) == 0
-    end
-
-    test "it does not return chats with users you blocked", %{conn: conn, user: user} do
-      recipient = insert(:user)
-
-      {:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats")
-        |> json_response_and_validate_schema(200)
-
-      assert length(result) == 1
-
-      User.block(user, recipient)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats")
-        |> json_response_and_validate_schema(200)
-
-      assert length(result) == 0
-    end
-
-    test "it returns all chats", %{conn: conn, user: user} do
-      Enum.each(1..30, fn _ ->
-        recipient = insert(:user)
-        {:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
-      end)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats")
-        |> json_response_and_validate_schema(200)
-
-      assert length(result) == 30
-    end
-
-    test "it return a list of chats the current user is participating in, in descending order of updates",
-         %{conn: conn, user: user} do
-      har = insert(:user)
-      jafnhar = insert(:user)
-      tridi = insert(:user)
-
-      {:ok, chat_1} = Chat.get_or_create(user.id, har.ap_id)
-      :timer.sleep(1000)
-      {:ok, _chat_2} = Chat.get_or_create(user.id, jafnhar.ap_id)
-      :timer.sleep(1000)
-      {:ok, chat_3} = Chat.get_or_create(user.id, tridi.ap_id)
-      :timer.sleep(1000)
-
-      # bump the second one
-      {:ok, chat_2} = Chat.bump_or_create(user.id, jafnhar.ap_id)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats")
-        |> json_response_and_validate_schema(200)
-
-      ids = Enum.map(result, & &1["id"])
-
-      assert ids == [
-               chat_2.id |> to_string(),
-               chat_3.id |> to_string(),
-               chat_1.id |> to_string()
-             ]
-    end
-
-    test "it is not affected by :restrict_unauthenticated setting (issue #1973)", %{
-      conn: conn,
-      user: user
-    } do
-      clear_config([:restrict_unauthenticated, :profiles, :local], true)
-      clear_config([:restrict_unauthenticated, :profiles, :remote], true)
-
-      user2 = insert(:user)
-      user3 = insert(:user, local: false)
-
-      {:ok, _chat_12} = Chat.get_or_create(user.id, user2.ap_id)
-      {:ok, _chat_13} = Chat.get_or_create(user.id, user3.ap_id)
-
-      result =
-        conn
-        |> get("/api/v1/pleroma/chats")
-        |> json_response_and_validate_schema(200)
-
-      account_ids = Enum.map(result, &get_in(&1, ["account", "id"]))
-      assert Enum.sort(account_ids) == Enum.sort([user2.id, user3.id])
-    end
-  end
-end
diff --git a/test/web/pleroma_api/controllers/conversation_controller_test.exs b/test/web/pleroma_api/controllers/conversation_controller_test.exs
deleted file mode 100644
index e6d0b3e37..000000000
--- a/test/web/pleroma_api/controllers/conversation_controller_test.exs
+++ /dev/null
@@ -1,136 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.ConversationControllerTest do
-  use Pleroma.Web.ConnCase
-
-  alias Pleroma.Conversation.Participation
-  alias Pleroma.Repo
-  alias Pleroma.User
-  alias Pleroma.Web.CommonAPI
-
-  import Pleroma.Factory
-
-  test "/api/v1/pleroma/conversations/:id" do
-    user = insert(:user)
-    %{user: other_user, conn: conn} = oauth_access(["read:statuses"])
-
-    {:ok, _activity} =
-      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
-
-    [participation] = Participation.for_user(other_user)
-
-    result =
-      conn
-      |> get("/api/v1/pleroma/conversations/#{participation.id}")
-      |> json_response_and_validate_schema(200)
-
-    assert result["id"] == participation.id |> to_string()
-  end
-
-  test "/api/v1/pleroma/conversations/:id/statuses" do
-    user = insert(:user)
-    %{user: other_user, conn: conn} = oauth_access(["read:statuses"])
-    third_user = insert(:user)
-
-    {:ok, _activity} =
-      CommonAPI.post(user, %{status: "Hi @#{third_user.nickname}!", visibility: "direct"})
-
-    {:ok, activity} =
-      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
-
-    [participation] = Participation.for_user(other_user)
-
-    {:ok, activity_two} =
-      CommonAPI.post(other_user, %{
-        status: "Hi!",
-        in_reply_to_status_id: activity.id,
-        in_reply_to_conversation_id: participation.id
-      })
-
-    result =
-      conn
-      |> get("/api/v1/pleroma/conversations/#{participation.id}/statuses")
-      |> json_response_and_validate_schema(200)
-
-    assert length(result) == 2
-
-    id_one = activity.id
-    id_two = activity_two.id
-    assert [%{"id" => ^id_one}, %{"id" => ^id_two}] = result
-
-    {:ok, %{id: id_three}} =
-      CommonAPI.post(other_user, %{
-        status: "Bye!",
-        in_reply_to_status_id: activity.id,
-        in_reply_to_conversation_id: participation.id
-      })
-
-    assert [%{"id" => ^id_two}, %{"id" => ^id_three}] =
-             conn
-             |> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?limit=2")
-             |> json_response_and_validate_schema(:ok)
-
-    assert [%{"id" => ^id_three}] =
-             conn
-             |> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?min_id=#{id_two}")
-             |> json_response_and_validate_schema(:ok)
-  end
-
-  test "PATCH /api/v1/pleroma/conversations/:id" do
-    %{user: user, conn: conn} = oauth_access(["write:conversations"])
-    other_user = insert(:user)
-
-    {:ok, _activity} = CommonAPI.post(user, %{status: "Hi", visibility: "direct"})
-
-    [participation] = Participation.for_user(user)
-
-    participation = Repo.preload(participation, :recipients)
-
-    user = User.get_cached_by_id(user.id)
-    assert [user] == participation.recipients
-    assert other_user not in participation.recipients
-
-    query = "recipients[]=#{user.id}&recipients[]=#{other_user.id}"
-
-    result =
-      conn
-      |> patch("/api/v1/pleroma/conversations/#{participation.id}?#{query}")
-      |> json_response_and_validate_schema(200)
-
-    assert result["id"] == participation.id |> to_string
-
-    [participation] = Participation.for_user(user)
-    participation = Repo.preload(participation, :recipients)
-
-    assert user in participation.recipients
-    assert other_user in participation.recipients
-  end
-
-  test "POST /api/v1/pleroma/conversations/read" do
-    user = insert(:user)
-    %{user: other_user, conn: conn} = oauth_access(["write:conversations"])
-
-    {:ok, _activity} =
-      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
-
-    {:ok, _activity} =
-      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
-
-    [participation2, participation1] = Participation.for_user(other_user)
-    assert Participation.get(participation2.id).read == false
-    assert Participation.get(participation1.id).read == false
-    assert User.get_cached_by_id(other_user.id).unread_conversation_count == 2
-
-    [%{"unread" => false}, %{"unread" => false}] =
-      conn
-      |> post("/api/v1/pleroma/conversations/read", %{})
-      |> json_response_and_validate_schema(200)
-
-    [participation2, participation1] = Participation.for_user(other_user)
-    assert Participation.get(participation2.id).read == true
-    assert Participation.get(participation1.id).read == true
-    assert User.get_cached_by_id(other_user.id).unread_conversation_count == 0
-  end
-end
diff --git a/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs b/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
deleted file mode 100644
index e113bb15f..000000000
--- a/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
+++ /dev/null
@@ -1,861 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
-  use Pleroma.Web.ConnCase
-
-  import Tesla.Mock
-  import Pleroma.Factory
-
-  @emoji_path Path.join(
-                Pleroma.Config.get!([:instance, :static_dir]),
-                "emoji"
-              )
-  setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
-
-  setup do: clear_config([:instance, :public], true)
-
-  setup do
-    admin = insert(:user, is_admin: true)
-    token = insert(:oauth_admin_token, user: admin)
-
-    admin_conn =
-      build_conn()
-      |> assign(:user, admin)
-      |> assign(:token, token)
-
-    Pleroma.Emoji.reload()
-    {:ok, %{admin_conn: admin_conn}}
-  end
-
-  test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do
-    Config.put([:instance, :public], false)
-    conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
-  end
-
-  test "GET /api/pleroma/emoji/packs", %{conn: conn} do
-    resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
-
-    assert resp["count"] == 3
-
-    assert resp["packs"]
-           |> Map.keys()
-           |> length() == 3
-
-    shared = resp["packs"]["test_pack"]
-    assert shared["files"] == %{"blank" => "blank.png", "blank2" => "blank2.png"}
-    assert Map.has_key?(shared["pack"], "download-sha256")
-    assert shared["pack"]["can-download"]
-    assert shared["pack"]["share-files"]
-
-    non_shared = resp["packs"]["test_pack_nonshared"]
-    assert non_shared["pack"]["share-files"] == false
-    assert non_shared["pack"]["can-download"] == false
-
-    resp =
-      conn
-      |> get("/api/pleroma/emoji/packs?page_size=1")
-      |> json_response_and_validate_schema(200)
-
-    assert resp["count"] == 3
-
-    packs = Map.keys(resp["packs"])
-
-    assert length(packs) == 1
-
-    [pack1] = packs
-
-    resp =
-      conn
-      |> get("/api/pleroma/emoji/packs?page_size=1&page=2")
-      |> json_response_and_validate_schema(200)
-
-    assert resp["count"] == 3
-    packs = Map.keys(resp["packs"])
-    assert length(packs) == 1
-    [pack2] = packs
-
-    resp =
-      conn
-      |> get("/api/pleroma/emoji/packs?page_size=1&page=3")
-      |> json_response_and_validate_schema(200)
-
-    assert resp["count"] == 3
-    packs = Map.keys(resp["packs"])
-    assert length(packs) == 1
-    [pack3] = packs
-    assert [pack1, pack2, pack3] |> Enum.uniq() |> length() == 3
-  end
-
-  describe "GET /api/pleroma/emoji/packs/remote" do
-    test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
-      resp =
-        conn
-        |> get("/api/pleroma/emoji/packs")
-        |> json_response_and_validate_schema(200)
-
-      mock(fn
-        %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
-          json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
-
-        %{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
-          json(%{metadata: %{features: ["shareable_emoji_packs"]}})
-
-        %{method: :get, url: "https://example.com/api/pleroma/emoji/packs"} ->
-          json(resp)
-      end)
-
-      assert admin_conn
-             |> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
-             |> json_response_and_validate_schema(200) == resp
-    end
-
-    test "non shareable instance", %{admin_conn: admin_conn} do
-      mock(fn
-        %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
-          json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
-
-        %{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
-          json(%{metadata: %{features: []}})
-      end)
-
-      assert admin_conn
-             |> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
-             |> json_response_and_validate_schema(500) == %{
-               "error" => "The requested instance does not support sharing emoji packs"
-             }
-    end
-  end
-
-  describe "GET /api/pleroma/emoji/packs/:name/archive" do
-    test "download shared pack", %{conn: conn} do
-      resp =
-        conn
-        |> get("/api/pleroma/emoji/packs/test_pack/archive")
-        |> response(200)
-
-      {:ok, arch} = :zip.unzip(resp, [:memory])
-
-      assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
-      assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
-    end
-
-    test "non existing pack", %{conn: conn} do
-      assert conn
-             |> get("/api/pleroma/emoji/packs/test_pack_for_import/archive")
-             |> json_response_and_validate_schema(:not_found) == %{
-               "error" => "Pack test_pack_for_import does not exist"
-             }
-    end
-
-    test "non downloadable pack", %{conn: conn} do
-      assert conn
-             |> get("/api/pleroma/emoji/packs/test_pack_nonshared/archive")
-             |> json_response_and_validate_schema(:forbidden) == %{
-               "error" =>
-                 "Pack test_pack_nonshared cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
-             }
-    end
-  end
-
-  describe "POST /api/pleroma/emoji/packs/download" do
-    test "shared pack from remote and non shared from fallback-src", %{
-      admin_conn: admin_conn,
-      conn: conn
-    } do
-      mock(fn
-        %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
-          json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
-
-        %{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
-          json(%{metadata: %{features: ["shareable_emoji_packs"]}})
-
-        %{
-          method: :get,
-          url: "https://example.com/api/pleroma/emoji/packs/test_pack"
-        } ->
-          conn
-          |> get("/api/pleroma/emoji/packs/test_pack")
-          |> json_response_and_validate_schema(200)
-          |> json()
-
-        %{
-          method: :get,
-          url: "https://example.com/api/pleroma/emoji/packs/test_pack/archive"
-        } ->
-          conn
-          |> get("/api/pleroma/emoji/packs/test_pack/archive")
-          |> response(200)
-          |> text()
-
-        %{
-          method: :get,
-          url: "https://example.com/api/pleroma/emoji/packs/test_pack_nonshared"
-        } ->
-          conn
-          |> get("/api/pleroma/emoji/packs/test_pack_nonshared")
-          |> json_response_and_validate_schema(200)
-          |> json()
-
-        %{
-          method: :get,
-          url: "https://nonshared-pack"
-        } ->
-          text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
-      end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/download", %{
-               url: "https://example.com",
-               name: "test_pack",
-               as: "test_pack2"
-             })
-             |> json_response_and_validate_schema(200) == "ok"
-
-      assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
-      assert File.exists?("#{@emoji_path}/test_pack2/blank.png")
-
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/test_pack2")
-             |> json_response_and_validate_schema(200) == "ok"
-
-      refute File.exists?("#{@emoji_path}/test_pack2")
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post(
-               "/api/pleroma/emoji/packs/download",
-               %{
-                 url: "https://example.com",
-                 name: "test_pack_nonshared",
-                 as: "test_pack_nonshared2"
-               }
-             )
-             |> json_response_and_validate_schema(200) == "ok"
-
-      assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
-      assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")
-
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/test_pack_nonshared2")
-             |> json_response_and_validate_schema(200) == "ok"
-
-      refute File.exists?("#{@emoji_path}/test_pack_nonshared2")
-    end
-
-    test "nonshareable instance", %{admin_conn: admin_conn} do
-      mock(fn
-        %{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
-          json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})
-
-        %{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
-          json(%{metadata: %{features: []}})
-      end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post(
-               "/api/pleroma/emoji/packs/download",
-               %{
-                 url: "https://old-instance",
-                 name: "test_pack",
-                 as: "test_pack2"
-               }
-             )
-             |> json_response_and_validate_schema(500) == %{
-               "error" => "The requested instance does not support sharing emoji packs"
-             }
-    end
-
-    test "checksum fail", %{admin_conn: admin_conn} do
-      mock(fn
-        %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
-          json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
-
-        %{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
-          json(%{metadata: %{features: ["shareable_emoji_packs"]}})
-
-        %{
-          method: :get,
-          url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha"
-        } ->
-          {:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
-          %Tesla.Env{status: 200, body: Jason.encode!(pack)}
-
-        %{
-          method: :get,
-          url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha/archive"
-        } ->
-          %Tesla.Env{
-            status: 200,
-            body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
-          }
-      end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/download", %{
-               url: "https://example.com",
-               name: "pack_bad_sha",
-               as: "pack_bad_sha2"
-             })
-             |> json_response_and_validate_schema(:internal_server_error) == %{
-               "error" => "SHA256 for the pack doesn't match the one sent by the server"
-             }
-    end
-
-    test "other error", %{admin_conn: admin_conn} do
-      mock(fn
-        %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
-          json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
-
-        %{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
-          json(%{metadata: %{features: ["shareable_emoji_packs"]}})
-
-        %{
-          method: :get,
-          url: "https://example.com/api/pleroma/emoji/packs/test_pack"
-        } ->
-          {:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
-          %Tesla.Env{status: 200, body: Jason.encode!(pack)}
-      end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/download", %{
-               url: "https://example.com",
-               name: "test_pack",
-               as: "test_pack2"
-             })
-             |> json_response_and_validate_schema(:internal_server_error) == %{
-               "error" =>
-                 "The pack was not set as shared and there is no fallback src to download from"
-             }
-    end
-  end
-
-  describe "PATCH /api/pleroma/emoji/packs/:name" do
-    setup do
-      pack_file = "#{@emoji_path}/test_pack/pack.json"
-      original_content = File.read!(pack_file)
-
-      on_exit(fn ->
-        File.write!(pack_file, original_content)
-      end)
-
-      {:ok,
-       pack_file: pack_file,
-       new_data: %{
-         "license" => "Test license changed",
-         "homepage" => "https://pleroma.social",
-         "description" => "Test description",
-         "share-files" => false
-       }}
-    end
-
-    test "for a pack without a fallback source", ctx do
-      assert ctx[:admin_conn]
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack", %{"metadata" => ctx[:new_data]})
-             |> json_response_and_validate_schema(200) == ctx[:new_data]
-
-      assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
-    end
-
-    test "for a pack with a fallback source", ctx do
-      mock(fn
-        %{
-          method: :get,
-          url: "https://nonshared-pack"
-        } ->
-          text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
-      end)
-
-      new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
-
-      new_data_with_sha =
-        Map.put(
-          new_data,
-          "fallback-src-sha256",
-          "1967BB4E42BCC34BCC12D57BE7811D3B7BE52F965BCE45C87BD377B9499CE11D"
-        )
-
-      assert ctx[:admin_conn]
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
-             |> json_response_and_validate_schema(200) == new_data_with_sha
-
-      assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
-    end
-
-    test "when the fallback source doesn't have all the files", ctx do
-      mock(fn
-        %{
-          method: :get,
-          url: "https://nonshared-pack"
-        } ->
-          {:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
-          text(empty_arch)
-      end)
-
-      new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
-
-      assert ctx[:admin_conn]
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "The fallback archive does not have all files specified in pack.json"
-             }
-    end
-  end
-
-  describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/:name/files" do
-    setup do
-      pack_file = "#{@emoji_path}/test_pack/pack.json"
-      original_content = File.read!(pack_file)
-
-      on_exit(fn ->
-        File.write!(pack_file, original_content)
-      end)
-
-      :ok
-    end
-
-    test "create shortcode exists", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank",
-               filename: "dir/blank.png",
-               file: %Plug.Upload{
-                 filename: "blank.png",
-                 path: "#{@emoji_path}/test_pack/blank.png"
-               }
-             })
-             |> json_response_and_validate_schema(:conflict) == %{
-               "error" => "An emoji with the \"blank\" shortcode already exists"
-             }
-    end
-
-    test "don't rewrite old emoji", %{admin_conn: admin_conn} do
-      on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank3",
-               filename: "dir/blank.png",
-               file: %Plug.Upload{
-                 filename: "blank.png",
-                 path: "#{@emoji_path}/test_pack/blank.png"
-               }
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "blank" => "blank.png",
-               "blank2" => "blank2.png",
-               "blank3" => "dir/blank.png"
-             }
-
-      assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank",
-               new_shortcode: "blank2",
-               new_filename: "dir_2/blank_3.png"
-             })
-             |> json_response_and_validate_schema(:conflict) == %{
-               "error" =>
-                 "New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
-             }
-    end
-
-    test "rewrite old emoji with force option", %{admin_conn: admin_conn} do
-      on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir_2/") end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank3",
-               filename: "dir/blank.png",
-               file: %Plug.Upload{
-                 filename: "blank.png",
-                 path: "#{@emoji_path}/test_pack/blank.png"
-               }
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "blank" => "blank.png",
-               "blank2" => "blank2.png",
-               "blank3" => "dir/blank.png"
-             }
-
-      assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank3",
-               new_shortcode: "blank4",
-               new_filename: "dir_2/blank_3.png",
-               force: true
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "blank" => "blank.png",
-               "blank2" => "blank2.png",
-               "blank4" => "dir_2/blank_3.png"
-             }
-
-      assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
-    end
-
-    test "with empty filename", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank2",
-               filename: "",
-               file: %Plug.Upload{
-                 filename: "blank.png",
-                 path: "#{@emoji_path}/test_pack/blank.png"
-               }
-             })
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack name, shortcode or filename cannot be empty"
-             }
-    end
-
-    test "add file with not loaded pack", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/not_loaded/files", %{
-               shortcode: "blank3",
-               filename: "dir/blank.png",
-               file: %Plug.Upload{
-                 filename: "blank.png",
-                 path: "#{@emoji_path}/test_pack/blank.png"
-               }
-             })
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack \"not_loaded\" is not found"
-             }
-    end
-
-    test "remove file with not loaded pack", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=blank3")
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack \"not_loaded\" is not found"
-             }
-    end
-
-    test "remove file with empty shortcode", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=")
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack name or shortcode cannot be empty"
-             }
-    end
-
-    test "update file with not loaded pack", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/not_loaded/files", %{
-               shortcode: "blank4",
-               new_shortcode: "blank3",
-               new_filename: "dir_2/blank_3.png"
-             })
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack \"not_loaded\" is not found"
-             }
-    end
-
-    test "new with shortcode as file with update", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank4",
-               filename: "dir/blank.png",
-               file: %Plug.Upload{
-                 filename: "blank.png",
-                 path: "#{@emoji_path}/test_pack/blank.png"
-               }
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "blank" => "blank.png",
-               "blank4" => "dir/blank.png",
-               "blank2" => "blank2.png"
-             }
-
-      assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank4",
-               new_shortcode: "blank3",
-               new_filename: "dir_2/blank_3.png"
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "blank3" => "dir_2/blank_3.png",
-               "blank" => "blank.png",
-               "blank2" => "blank2.png"
-             }
-
-      refute File.exists?("#{@emoji_path}/test_pack/dir/")
-      assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
-
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
-             |> json_response_and_validate_schema(200) == %{
-               "blank" => "blank.png",
-               "blank2" => "blank2.png"
-             }
-
-      refute File.exists?("#{@emoji_path}/test_pack/dir_2/")
-
-      on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
-    end
-
-    test "new with shortcode from url", %{admin_conn: admin_conn} do
-      mock(fn
-        %{
-          method: :get,
-          url: "https://test-blank/blank_url.png"
-        } ->
-          text(File.read!("#{@emoji_path}/test_pack/blank.png"))
-      end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank_url",
-               file: "https://test-blank/blank_url.png"
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "blank_url" => "blank_url.png",
-               "blank" => "blank.png",
-               "blank2" => "blank2.png"
-             }
-
-      assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")
-
-      on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/blank_url.png") end)
-    end
-
-    test "new without shortcode", %{admin_conn: admin_conn} do
-      on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/shortcode.png") end)
-
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> post("/api/pleroma/emoji/packs/test_pack/files", %{
-               file: %Plug.Upload{
-                 filename: "shortcode.png",
-                 path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
-               }
-             })
-             |> json_response_and_validate_schema(200) == %{
-               "shortcode" => "shortcode.png",
-               "blank" => "blank.png",
-               "blank2" => "blank2.png"
-             }
-    end
-
-    test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "Emoji \"blank3\" does not exist"
-             }
-    end
-
-    test "update non existing emoji", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> put_req_header("content-type", "multipart/form-data")
-             |> patch("/api/pleroma/emoji/packs/test_pack/files", %{
-               shortcode: "blank3",
-               new_shortcode: "blank4",
-               new_filename: "dir_2/blank_3.png"
-             })
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "Emoji \"blank3\" does not exist"
-             }
-    end
-
-    test "update with empty shortcode", %{admin_conn: admin_conn} do
-      assert %{
-               "error" => "Missing field: new_shortcode."
-             } =
-               admin_conn
-               |> put_req_header("content-type", "multipart/form-data")
-               |> patch("/api/pleroma/emoji/packs/test_pack/files", %{
-                 shortcode: "blank",
-                 new_filename: "dir_2/blank_3.png"
-               })
-               |> json_response_and_validate_schema(:bad_request)
-    end
-  end
-
-  describe "POST/DELETE /api/pleroma/emoji/packs/:name" do
-    test "creating and deleting a pack", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> post("/api/pleroma/emoji/packs/test_created")
-             |> json_response_and_validate_schema(200) == "ok"
-
-      assert File.exists?("#{@emoji_path}/test_created/pack.json")
-
-      assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
-               "pack" => %{},
-               "files" => %{},
-               "files_count" => 0
-             }
-
-      assert admin_conn
-             |> delete("/api/pleroma/emoji/packs/test_created")
-             |> json_response_and_validate_schema(200) == "ok"
-
-      refute File.exists?("#{@emoji_path}/test_created/pack.json")
-    end
-
-    test "if pack exists", %{admin_conn: admin_conn} do
-      path = Path.join(@emoji_path, "test_created")
-      File.mkdir(path)
-      pack_file = Jason.encode!(%{files: %{}, pack: %{}})
-      File.write!(Path.join(path, "pack.json"), pack_file)
-
-      assert admin_conn
-             |> post("/api/pleroma/emoji/packs/test_created")
-             |> json_response_and_validate_schema(:conflict) == %{
-               "error" => "A pack named \"test_created\" already exists"
-             }
-
-      on_exit(fn -> File.rm_rf(path) end)
-    end
-
-    test "with empty name", %{admin_conn: admin_conn} do
-      assert admin_conn
-             |> post("/api/pleroma/emoji/packs/ ")
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack name cannot be empty"
-             }
-    end
-  end
-
-  test "deleting nonexisting pack", %{admin_conn: admin_conn} do
-    assert admin_conn
-           |> delete("/api/pleroma/emoji/packs/non_existing")
-           |> json_response_and_validate_schema(:not_found) == %{
-             "error" => "Pack non_existing does not exist"
-           }
-  end
-
-  test "deleting with empty name", %{admin_conn: admin_conn} do
-    assert admin_conn
-           |> delete("/api/pleroma/emoji/packs/ ")
-           |> json_response_and_validate_schema(:bad_request) == %{
-             "error" => "pack name cannot be empty"
-           }
-  end
-
-  test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
-    on_exit(fn ->
-      File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
-      File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
-    end)
-
-    resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
-
-    refute Map.has_key?(resp["packs"], "test_pack_for_import")
-
-    assert admin_conn
-           |> get("/api/pleroma/emoji/packs/import")
-           |> json_response_and_validate_schema(200) == ["test_pack_for_import"]
-
-    resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
-    assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}
-
-    File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
-    refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")
-
-    emoji_txt_content = """
-    blank, blank.png, Fun
-    blank2, blank.png
-    foo, /emoji/test_pack_for_import/blank.png
-    bar
-    """
-
-    File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)
-
-    assert admin_conn
-           |> get("/api/pleroma/emoji/packs/import")
-           |> json_response_and_validate_schema(200) == ["test_pack_for_import"]
-
-    resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
-
-    assert resp["packs"]["test_pack_for_import"]["files"] == %{
-             "blank" => "blank.png",
-             "blank2" => "blank.png",
-             "foo" => "blank.png"
-           }
-  end
-
-  describe "GET /api/pleroma/emoji/packs/:name" do
-    test "shows pack.json", %{conn: conn} do
-      assert %{
-               "files" => files,
-               "files_count" => 2,
-               "pack" => %{
-                 "can-download" => true,
-                 "description" => "Test description",
-                 "download-sha256" => _,
-                 "homepage" => "https://pleroma.social",
-                 "license" => "Test license",
-                 "share-files" => true
-               }
-             } =
-               conn
-               |> get("/api/pleroma/emoji/packs/test_pack")
-               |> json_response_and_validate_schema(200)
-
-      assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}
-
-      assert %{
-               "files" => files,
-               "files_count" => 2
-             } =
-               conn
-               |> get("/api/pleroma/emoji/packs/test_pack?page_size=1")
-               |> json_response_and_validate_schema(200)
-
-      assert files |> Map.keys() |> length() == 1
-
-      assert %{
-               "files" => files,
-               "files_count" => 2
-             } =
-               conn
-               |> get("/api/pleroma/emoji/packs/test_pack?page_size=1&page=2")
-               |> json_response_and_validate_schema(200)
-
-      assert files |> Map.keys() |> length() == 1
-    end
-
-    test "non existing pack", %{conn: conn} do
-      assert conn
-             |> get("/api/pleroma/emoji/packs/non_existing")
-             |> json_response_and_validate_schema(:not_found) == %{
-               "error" => "Pack non_existing does not exist"
-             }
-    end
-
-    test "error name", %{conn: conn} do
-      assert conn
-             |> get("/api/pleroma/emoji/packs/ ")
-             |> json_response_and_validate_schema(:bad_request) == %{
-               "error" => "pack name cannot be empty"
-             }
-    end
-  end
-end
diff --git a/test/web/pleroma_api/controllers/emoji_reaction_controller_test.exs b/test/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
deleted file mode 100644
index 3deab30d1..000000000
--- a/test/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
+++ /dev/null
@@ -1,149 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.EmojiReactionControllerTest do
-  use Oban.Testing, repo: Pleroma.Repo
-  use Pleroma.Web.ConnCase
-
-  alias Pleroma.Object
-  alias Pleroma.Tests.ObanHelpers
-  alias Pleroma.User
-  alias Pleroma.Web.CommonAPI
-
-  import Pleroma.Factory
-
-  test "PUT /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
-    user = insert(:user)
-    other_user = insert(:user)
-
-    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
-
-    result =
-      conn
-      |> assign(:user, other_user)
-      |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
-      |> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/☕")
-      |> json_response_and_validate_schema(200)
-
-    # We return the status, but this our implementation detail.
-    assert %{"id" => id} = result
-    assert to_string(activity.id) == id
-
-    assert result["pleroma"]["emoji_reactions"] == [
-             %{"name" => "☕", "count" => 1, "me" => true}
-           ]
-
-    # Reacting with a non-emoji
-    assert conn
-           |> assign(:user, other_user)
-           |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
-           |> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/x")
-           |> json_response_and_validate_schema(400)
-  end
-
-  test "DELETE /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
-    user = insert(:user)
-    other_user = insert(:user)
-
-    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
-    {:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
-
-    ObanHelpers.perform_all()
-
-    result =
-      conn
-      |> assign(:user, other_user)
-      |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
-      |> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/☕")
-
-    assert %{"id" => id} = json_response_and_validate_schema(result, 200)
-    assert to_string(activity.id) == id
-
-    ObanHelpers.perform_all()
-
-    object = Object.get_by_ap_id(activity.data["object"])
-
-    assert object.data["reaction_count"] == 0
-  end
-
-  test "GET /api/v1/pleroma/statuses/:id/reactions", %{conn: conn} do
-    user = insert(:user)
-    other_user = insert(:user)
-    doomed_user = insert(:user)
-
-    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
-
-    result =
-      conn
-      |> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
-      |> json_response_and_validate_schema(200)
-
-    assert result == []
-
-    {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
-    {:ok, _} = CommonAPI.react_with_emoji(activity.id, doomed_user, "🎅")
-
-    User.perform(:delete, doomed_user)
-
-    result =
-      conn
-      |> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
-      |> json_response_and_validate_schema(200)
-
-    [%{"name" => "🎅", "count" => 1, "accounts" => [represented_user], "me" => false}] = result
-
-    assert represented_user["id"] == other_user.id
-
-    result =
-      conn
-      |> assign(:user, other_user)
-      |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:statuses"]))
-      |> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
-      |> json_response_and_validate_schema(200)
-
-    assert [%{"name" => "🎅", "count" => 1, "accounts" => [_represented_user], "me" => true}] =
-             result
-  end
-
-  test "GET /api/v1/pleroma/statuses/:id/reactions with :show_reactions disabled", %{conn: conn} do
-    clear_config([:instance, :show_reactions], false)
-
-    user = insert(:user)
-    other_user = insert(:user)
-
-    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
-    {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
-
-    result =
-      conn
-      |> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
-      |> json_response_and_validate_schema(200)
-
-    assert result == []
-  end
-
-  test "GET /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
-    user = insert(:user)
-    other_user = insert(:user)
-
-    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
-
-    result =
-      conn
-      |> get("/api/v1/pleroma/statuses/#{activity.id}/reactions/🎅")
-      |> json_response_and_validate_schema(200)
-
-    assert result == []
-
-    {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
-    {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
-
-    assert [%{"name" => "🎅", "count" => 1, "accounts" => [represented_user], "me" => false}] =
-             conn
-             |> get("/api/v1/pleroma/statuses/#{activity.id}/reactions/🎅")
-             |> json_response_and_validate_schema(200)
-
-    assert represented_user["id"] == other_user.id
-  end
-end
diff --git a/test/web/pleroma_api/controllers/mascot_controller_test.exs b/test/web/pleroma_api/controllers/mascot_controller_test.exs
deleted file mode 100644
index e2ead6e15..000000000
--- a/test/web/pleroma_api/controllers/mascot_controller_test.exs
+++ /dev/null
@@ -1,73 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.MascotControllerTest do
-  use Pleroma.Web.ConnCase
-
-  alias Pleroma.User
-
-  test "mascot upload" do
-    %{conn: conn} = oauth_access(["write:accounts"])
-
-    non_image_file = %Plug.Upload{
-      content_type: "audio/mpeg",
-      path: Path.absname("test/fixtures/sound.mp3"),
-      filename: "sound.mp3"
-    }
-
-    ret_conn =
-      conn
-      |> put_req_header("content-type", "multipart/form-data")
-      |> put("/api/v1/pleroma/mascot", %{"file" => non_image_file})
-
-    assert json_response_and_validate_schema(ret_conn, 415)
-
-    file = %Plug.Upload{
-      content_type: "image/jpg",
-      path: Path.absname("test/fixtures/image.jpg"),
-      filename: "an_image.jpg"
-    }
-
-    conn =
-      conn
-      |> put_req_header("content-type", "multipart/form-data")
-      |> put("/api/v1/pleroma/mascot", %{"file" => file})
-
-    assert %{"id" => _, "type" => image} = json_response_and_validate_schema(conn, 200)
-  end
-
-  test "mascot retrieving" do
-    %{user: user, conn: conn} = oauth_access(["read:accounts", "write:accounts"])
-
-    # When user hasn't set a mascot, we should just get pleroma tan back
-    ret_conn = get(conn, "/api/v1/pleroma/mascot")
-
-    assert %{"url" => url} = json_response_and_validate_schema(ret_conn, 200)
-    assert url =~ "pleroma-fox-tan-smol"
-
-    # When a user sets their mascot, we should get that back
-    file = %Plug.Upload{
-      content_type: "image/jpg",
-      path: Path.absname("test/fixtures/image.jpg"),
-      filename: "an_image.jpg"
-    }
-
-    ret_conn =
-      conn
-      |> put_req_header("content-type", "multipart/form-data")
-      |> put("/api/v1/pleroma/mascot", %{"file" => file})
-
-    assert json_response_and_validate_schema(ret_conn, 200)
-
-    user = User.get_cached_by_id(user.id)
-
-    conn =
-      conn
-      |> assign(:user, user)
-      |> get("/api/v1/pleroma/mascot")
-
-    assert %{"url" => url, "type" => "image"} = json_response_and_validate_schema(conn, 200)
-    assert url =~ "an_image"
-  end
-end
diff --git a/test/web/pleroma_api/controllers/notification_controller_test.exs b/test/web/pleroma_api/controllers/notification_controller_test.exs
deleted file mode 100644
index bb4fe6c49..000000000
--- a/test/web/pleroma_api/controllers/notification_controller_test.exs
+++ /dev/null
@@ -1,68 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.NotificationControllerTest do
-  use Pleroma.Web.ConnCase
-
-  alias Pleroma.Notification
-  alias Pleroma.Repo
-  alias Pleroma.Web.CommonAPI
-
-  import Pleroma.Factory
-
-  describe "POST /api/v1/pleroma/notifications/read" do
-    setup do: oauth_access(["write:notifications"])
-
-    test "it marks a single notification as read", %{user: user1, conn: conn} do
-      user2 = insert(:user)
-      {:ok, activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
-      {:ok, activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
-      {:ok, [notification1]} = Notification.create_notifications(activity1)
-      {:ok, [notification2]} = Notification.create_notifications(activity2)
-
-      response =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/notifications/read", %{id: notification1.id})
-        |> json_response_and_validate_schema(:ok)
-
-      assert %{"pleroma" => %{"is_seen" => true}} = response
-      assert Repo.get(Notification, notification1.id).seen
-      refute Repo.get(Notification, notification2.id).seen
-    end
-
-    test "it marks multiple notifications as read", %{user: user1, conn: conn} do
-      user2 = insert(:user)
-      {:ok, _activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
-      {:ok, _activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
-      {:ok, _activity3} = CommonAPI.post(user2, %{status: "HIE @#{user1.nickname}"})
-
-      [notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})
-
-      [response1, response2] =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/notifications/read", %{max_id: notification2.id})
-        |> json_response_and_validate_schema(:ok)
-
-      assert %{"pleroma" => %{"is_seen" => true}} = response1
-      assert %{"pleroma" => %{"is_seen" => true}} = response2
-      assert Repo.get(Notification, notification1.id).seen
-      assert Repo.get(Notification, notification2.id).seen
-      refute Repo.get(Notification, notification3.id).seen
-    end
-
-    test "it returns error when notification not found", %{conn: conn} do
-      response =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/notifications/read", %{
-          id: 22_222_222_222_222
-        })
-        |> json_response_and_validate_schema(:bad_request)
-
-      assert response == %{"error" => "Cannot get notification"}
-    end
-  end
-end
diff --git a/test/web/pleroma_api/controllers/scrobble_controller_test.exs b/test/web/pleroma_api/controllers/scrobble_controller_test.exs
deleted file mode 100644
index f39c07ac6..000000000
--- a/test/web/pleroma_api/controllers/scrobble_controller_test.exs
+++ /dev/null
@@ -1,60 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.ScrobbleControllerTest do
-  use Pleroma.Web.ConnCase
-
-  alias Pleroma.Web.CommonAPI
-
-  describe "POST /api/v1/pleroma/scrobble" do
-    test "works correctly" do
-      %{conn: conn} = oauth_access(["write"])
-
-      conn =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/v1/pleroma/scrobble", %{
-          "title" => "lain radio episode 1",
-          "artist" => "lain",
-          "album" => "lain radio",
-          "length" => "180000"
-        })
-
-      assert %{"title" => "lain radio episode 1"} = json_response_and_validate_schema(conn, 200)
-    end
-  end
-
-  describe "GET /api/v1/pleroma/accounts/:id/scrobbles" do
-    test "works correctly" do
-      %{user: user, conn: conn} = oauth_access(["read"])
-
-      {:ok, _activity} =
-        CommonAPI.listen(user, %{
-          title: "lain radio episode 1",
-          artist: "lain",
-          album: "lain radio"
-        })
-
-      {:ok, _activity} =
-        CommonAPI.listen(user, %{
-          title: "lain radio episode 2",
-          artist: "lain",
-          album: "lain radio"
-        })
-
-      {:ok, _activity} =
-        CommonAPI.listen(user, %{
-          title: "lain radio episode 3",
-          artist: "lain",
-          album: "lain radio"
-        })
-
-      conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/scrobbles")
-
-      result = json_response_and_validate_schema(conn, 200)
-
-      assert length(result) == 3
-    end
-  end
-end
diff --git a/test/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs b/test/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs
deleted file mode 100644
index d23d08a00..000000000
--- a/test/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs
+++ /dev/null
@@ -1,260 +0,0 @@
-defmodule Pleroma.Web.PleromaAPI.TwoFactorAuthenticationControllerTest do
-  use Pleroma.Web.ConnCase
-
-  import Pleroma.Factory
-  alias Pleroma.MFA.Settings
-  alias Pleroma.MFA.TOTP
-
-  describe "GET /api/pleroma/accounts/mfa/settings" do
-    test "returns user mfa settings for new user", %{conn: conn} do
-      token = insert(:oauth_token, scopes: ["read", "follow"])
-      token2 = insert(:oauth_token, scopes: ["write"])
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token.token}")
-             |> get("/api/pleroma/accounts/mfa")
-             |> json_response(:ok) == %{
-               "settings" => %{"enabled" => false, "totp" => false}
-             }
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token2.token}")
-             |> get("/api/pleroma/accounts/mfa")
-             |> json_response(403) == %{
-               "error" => "Insufficient permissions: read:security."
-             }
-    end
-
-    test "returns user mfa settings with enabled totp", %{conn: conn} do
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{
-            enabled: true,
-            totp: %Settings.TOTP{secret: "XXX", delivery_type: "app", confirmed: true}
-          }
-        )
-
-      token = insert(:oauth_token, scopes: ["read", "follow"], user: user)
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token.token}")
-             |> get("/api/pleroma/accounts/mfa")
-             |> json_response(:ok) == %{
-               "settings" => %{"enabled" => true, "totp" => true}
-             }
-    end
-  end
-
-  describe "GET /api/pleroma/accounts/mfa/backup_codes" do
-    test "returns backup codes", %{conn: conn} do
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{
-            backup_codes: ["1", "2", "3"],
-            totp: %Settings.TOTP{secret: "secret"}
-          }
-        )
-
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-      token2 = insert(:oauth_token, scopes: ["read"])
-
-      response =
-        conn
-        |> put_req_header("authorization", "Bearer #{token.token}")
-        |> get("/api/pleroma/accounts/mfa/backup_codes")
-        |> json_response(:ok)
-
-      assert [<<_::bytes-size(6)>>, <<_::bytes-size(6)>>] = response["codes"]
-      user = refresh_record(user)
-      mfa_settings = user.multi_factor_authentication_settings
-      assert mfa_settings.totp.secret == "secret"
-      refute mfa_settings.backup_codes == ["1", "2", "3"]
-      refute mfa_settings.backup_codes == []
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token2.token}")
-             |> get("/api/pleroma/accounts/mfa/backup_codes")
-             |> json_response(403) == %{
-               "error" => "Insufficient permissions: write:security."
-             }
-    end
-  end
-
-  describe "GET /api/pleroma/accounts/mfa/setup/totp" do
-    test "return errors when method is invalid", %{conn: conn} do
-      user = insert(:user)
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-
-      response =
-        conn
-        |> put_req_header("authorization", "Bearer #{token.token}")
-        |> get("/api/pleroma/accounts/mfa/setup/torf")
-        |> json_response(400)
-
-      assert response == %{"error" => "undefined method"}
-    end
-
-    test "returns key and provisioning_uri", %{conn: conn} do
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{backup_codes: ["1", "2", "3"]}
-        )
-
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-      token2 = insert(:oauth_token, scopes: ["read"])
-
-      response =
-        conn
-        |> put_req_header("authorization", "Bearer #{token.token}")
-        |> get("/api/pleroma/accounts/mfa/setup/totp")
-        |> json_response(:ok)
-
-      user = refresh_record(user)
-      mfa_settings = user.multi_factor_authentication_settings
-      secret = mfa_settings.totp.secret
-      refute mfa_settings.enabled
-      assert mfa_settings.backup_codes == ["1", "2", "3"]
-
-      assert response == %{
-               "key" => secret,
-               "provisioning_uri" => TOTP.provisioning_uri(secret, "#{user.email}")
-             }
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token2.token}")
-             |> get("/api/pleroma/accounts/mfa/setup/totp")
-             |> json_response(403) == %{
-               "error" => "Insufficient permissions: write:security."
-             }
-    end
-  end
-
-  describe "GET /api/pleroma/accounts/mfa/confirm/totp" do
-    test "returns success result", %{conn: conn} do
-      secret = TOTP.generate_secret()
-      code = TOTP.generate_token(secret)
-
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{
-            backup_codes: ["1", "2", "3"],
-            totp: %Settings.TOTP{secret: secret}
-          }
-        )
-
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-      token2 = insert(:oauth_token, scopes: ["read"])
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token.token}")
-             |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: code})
-             |> json_response(:ok)
-
-      settings = refresh_record(user).multi_factor_authentication_settings
-      assert settings.enabled
-      assert settings.totp.secret == secret
-      assert settings.totp.confirmed
-      assert settings.backup_codes == ["1", "2", "3"]
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token2.token}")
-             |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: code})
-             |> json_response(403) == %{
-               "error" => "Insufficient permissions: write:security."
-             }
-    end
-
-    test "returns error if password incorrect", %{conn: conn} do
-      secret = TOTP.generate_secret()
-      code = TOTP.generate_token(secret)
-
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{
-            backup_codes: ["1", "2", "3"],
-            totp: %Settings.TOTP{secret: secret}
-          }
-        )
-
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-
-      response =
-        conn
-        |> put_req_header("authorization", "Bearer #{token.token}")
-        |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "xxx", code: code})
-        |> json_response(422)
-
-      settings = refresh_record(user).multi_factor_authentication_settings
-      refute settings.enabled
-      refute settings.totp.confirmed
-      assert settings.backup_codes == ["1", "2", "3"]
-      assert response == %{"error" => "Invalid password."}
-    end
-
-    test "returns error if code incorrect", %{conn: conn} do
-      secret = TOTP.generate_secret()
-
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{
-            backup_codes: ["1", "2", "3"],
-            totp: %Settings.TOTP{secret: secret}
-          }
-        )
-
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-      token2 = insert(:oauth_token, scopes: ["read"])
-
-      response =
-        conn
-        |> put_req_header("authorization", "Bearer #{token.token}")
-        |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: "code"})
-        |> json_response(422)
-
-      settings = refresh_record(user).multi_factor_authentication_settings
-      refute settings.enabled
-      refute settings.totp.confirmed
-      assert settings.backup_codes == ["1", "2", "3"]
-      assert response == %{"error" => "invalid_token"}
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token2.token}")
-             |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: "code"})
-             |> json_response(403) == %{
-               "error" => "Insufficient permissions: write:security."
-             }
-    end
-  end
-
-  describe "DELETE /api/pleroma/accounts/mfa/totp" do
-    test "returns success result", %{conn: conn} do
-      user =
-        insert(:user,
-          multi_factor_authentication_settings: %Settings{
-            backup_codes: ["1", "2", "3"],
-            totp: %Settings.TOTP{secret: "secret"}
-          }
-        )
-
-      token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
-      token2 = insert(:oauth_token, scopes: ["read"])
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token.token}")
-             |> delete("/api/pleroma/accounts/mfa/totp", %{password: "test"})
-             |> json_response(:ok)
-
-      settings = refresh_record(user).multi_factor_authentication_settings
-      refute settings.enabled
-      assert settings.totp.secret == nil
-      refute settings.totp.confirmed
-
-      assert conn
-             |> put_req_header("authorization", "Bearer #{token2.token}")
-             |> delete("/api/pleroma/accounts/mfa/totp", %{password: "test"})
-             |> json_response(403) == %{
-               "error" => "Insufficient permissions: write:security."
-             }
-    end
-  end
-end