diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 1b7c03ebb..aad28a2d8 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -48,6 +48,7 @@ benchmark:
 
 unit-testing:
   stage: test
+  retry: 2
   cache: &testing_cache_policy
     <<: *global_cache_policy
     policy: pull
@@ -80,6 +81,7 @@ unit-testing:
 
 unit-testing-rum:
   stage: test
+  retry: 2
   cache: *testing_cache_policy
   services:
   - name: minibikini/postgres-with-rum:12
diff --git a/benchmarks/load_testing/users.ex b/benchmarks/load_testing/users.ex
index 1a8c6e22f..e4d0b22ff 100644
--- a/benchmarks/load_testing/users.ex
+++ b/benchmarks/load_testing/users.ex
@@ -55,7 +55,7 @@ defp generate_user(i) do
       name: "Test テスト User #{i}",
       email: "user#{i}@example.com",
       nickname: "nick#{i}",
-      password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
+      password_hash: Pbkdf2.hash_pwd_salt("test"),
       bio: "Tester Number #{i}",
       local: !remote
     }
diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
index a00bc0624..9d3d92b38 100644
--- a/lib/pleroma/application.ex
+++ b/lib/pleroma/application.ex
@@ -56,7 +56,7 @@ def start(_type, _args) do
         if (major == 22 and minor < 2) or major < 22 do
           raise "
             !!!OTP VERSION WARNING!!!
-            You are using gun adapter with OTP version #{version}, which doesn't support correct handling of unordered certificates chains.
+            You are using gun adapter with OTP version #{version}, which doesn't support correct handling of unordered certificates chains. Please update your Erlang/OTP to at least 22.2.
             "
         end
       else
diff --git a/lib/pleroma/bbs/authenticator.ex b/lib/pleroma/bbs/authenticator.ex
index e5b37f33e..d4494b003 100644
--- a/lib/pleroma/bbs/authenticator.ex
+++ b/lib/pleroma/bbs/authenticator.ex
@@ -4,7 +4,6 @@
 
 defmodule Pleroma.BBS.Authenticator do
   use Sshd.PasswordAuthenticator
-  alias Comeonin.Pbkdf2
   alias Pleroma.User
 
   def authenticate(username, password) do
@@ -12,7 +11,7 @@ def authenticate(username, password) do
     password = to_string(password)
 
     with %User{} = user <- User.get_by_nickname(username) do
-      Pbkdf2.checkpw(password, user.password_hash)
+      Pbkdf2.verify_pass(password, user.password_hash)
     else
       _e -> false
     end
diff --git a/lib/pleroma/bbs/handler.ex b/lib/pleroma/bbs/handler.ex
index c7bc8ef6c..12d64c2fe 100644
--- a/lib/pleroma/bbs/handler.ex
+++ b/lib/pleroma/bbs/handler.ex
@@ -66,7 +66,7 @@ def handle_command(%{user: user} = state, "r " <> text) do
 
     with %Activity{} <- Activity.get_by_id(activity_id),
          {:ok, _activity} <-
-           CommonAPI.post(user, %{"status" => rest, "in_reply_to_status_id" => activity_id}) do
+           CommonAPI.post(user, %{status: rest, in_reply_to_status_id: activity_id}) do
       IO.puts("Replied!")
     else
       _e -> IO.puts("Could not reply...")
@@ -78,7 +78,7 @@ def handle_command(%{user: user} = state, "r " <> text) do
   def handle_command(%{user: user} = state, "p " <> text) do
     text = String.trim(text)
 
-    with {:ok, _activity} <- CommonAPI.post(user, %{"status" => text}) do
+    with {:ok, _activity} <- CommonAPI.post(user, %{status: text}) do
       IO.puts("Posted!")
     else
       _e -> IO.puts("Could not post...")
diff --git a/lib/pleroma/mfa.ex b/lib/pleroma/mfa.ex
index d353a4dad..2b77f5426 100644
--- a/lib/pleroma/mfa.ex
+++ b/lib/pleroma/mfa.ex
@@ -7,7 +7,6 @@ defmodule Pleroma.MFA do
   The MFA context.
   """
 
-  alias Comeonin.Pbkdf2
   alias Pleroma.User
 
   alias Pleroma.MFA.BackupCodes
@@ -72,7 +71,7 @@ def invalidate_backup_code(%User{} = user, hash_code) do
   @spec generate_backup_codes(User.t()) :: {:ok, list(binary)} | {:error, String.t()}
   def generate_backup_codes(%User{} = user) do
     with codes <- BackupCodes.generate(),
-         hashed_codes <- Enum.map(codes, &Pbkdf2.hashpwsalt/1),
+         hashed_codes <- Enum.map(codes, &Pbkdf2.hash_pwd_salt/1),
          changeset <- Changeset.cast_backup_codes(user, hashed_codes),
          {:ok, _} <- User.update_and_set_cache(changeset) do
       {:ok, codes}
diff --git a/lib/pleroma/plugs/authentication_plug.ex b/lib/pleroma/plugs/authentication_plug.ex
index 0061c69dc..ae4a235bd 100644
--- a/lib/pleroma/plugs/authentication_plug.ex
+++ b/lib/pleroma/plugs/authentication_plug.ex
@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Plugs.AuthenticationPlug do
-  alias Comeonin.Pbkdf2
   alias Pleroma.Plugs.OAuthScopesPlug
   alias Pleroma.User
 
@@ -18,7 +17,7 @@ def checkpw(password, "$6" <> _ = password_hash) do
   end
 
   def checkpw(password, "$pbkdf2" <> _ = password_hash) do
-    Pbkdf2.checkpw(password, password_hash)
+    Pbkdf2.verify_pass(password, password_hash)
   end
 
   def checkpw(_password, _password_hash) do
@@ -37,7 +36,7 @@ def call(
         } = conn,
         _
       ) do
-    if Pbkdf2.checkpw(password, password_hash) do
+    if Pbkdf2.verify_pass(password, password_hash) do
       conn
       |> assign(:user, auth_user)
       |> OAuthScopesPlug.skip_plug()
@@ -47,7 +46,7 @@ def call(
   end
 
   def call(%{assigns: %{auth_credentials: %{password: _}}} = conn, _) do
-    Pbkdf2.dummy_checkpw()
+    Pbkdf2.no_user_verify()
     conn
   end
 
diff --git a/lib/pleroma/scheduled_activity.ex b/lib/pleroma/scheduled_activity.ex
index 8ff06a462..0937cb7db 100644
--- a/lib/pleroma/scheduled_activity.ex
+++ b/lib/pleroma/scheduled_activity.ex
@@ -40,7 +40,7 @@ defp with_media_attachments(
          %{changes: %{params: %{"media_ids" => media_ids} = params}} = changeset
        )
        when is_list(media_ids) do
-    media_attachments = Utils.attachments_from_ids(%{"media_ids" => media_ids})
+    media_attachments = Utils.attachments_from_ids(%{media_ids: media_ids})
 
     params =
       params
diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
index a86cc3202..cba391072 100644
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@@ -9,7 +9,6 @@ defmodule Pleroma.User do
   import Ecto.Query
   import Ecto, only: [assoc: 2]
 
-  alias Comeonin.Pbkdf2
   alias Ecto.Multi
   alias Pleroma.Activity
   alias Pleroma.Config
@@ -1926,7 +1925,7 @@ def get_ap_ids_by_nicknames(nicknames) do
   defp put_password_hash(
          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
        ) do
-    change(changeset, password_hash: Pbkdf2.hashpwsalt(password))
+    change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
   end
 
   defp put_password_hash(changeset), do: changeset
diff --git a/lib/pleroma/user/welcome_message.ex b/lib/pleroma/user/welcome_message.ex
index f0ac8ebae..f8f520285 100644
--- a/lib/pleroma/user/welcome_message.ex
+++ b/lib/pleroma/user/welcome_message.ex
@@ -10,8 +10,8 @@ def post_welcome_message_to_user(user) do
     with %User{} = sender_user <- welcome_user(),
          message when is_binary(message) <- welcome_message() do
       CommonAPI.post(sender_user, %{
-        "visibility" => "direct",
-        "status" => "@#{user.nickname}\n#{message}"
+        visibility: "direct",
+        status: "@#{user.nickname}\n#{message}"
       })
     else
       _ -> {:ok, nil}
diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index b4bccedef..db2499b88 100644
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -446,7 +446,6 @@ def block(blocker, blocked, activity_id \\ nil, local \\ true) do
   end
 
   defp do_block(blocker, blocked, activity_id, local) do
-    outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
     unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
 
     if unfollow_blocked do
@@ -454,8 +453,7 @@ defp do_block(blocker, blocked, activity_id, local) do
       if follow_activity, do: unfollow(blocker, blocked, nil, local)
     end
 
-    with true <- outgoing_blocks,
-         block_data <- make_block_data(blocker, blocked, activity_id),
+    with block_data <- make_block_data(blocker, blocked, activity_id),
          {:ok, activity} <- insert(block_data, local),
          _ <- notify_and_stream(activity),
          :ok <- maybe_federate(activity) do
diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
index f399e838a..afc63d6b7 100644
--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
@@ -592,6 +592,9 @@ def handle_incoming(
          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
          {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
+      User.update_follower_count(followed)
+      User.update_following_count(follower)
+
       ActivityPub.accept(%{
         to: follow_activity.data["to"],
         type: "Accept",
@@ -601,7 +604,8 @@ def handle_incoming(
         activity_id: id
       })
     else
-      _e -> :error
+      _e ->
+        :error
     end
   end
 
diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
index 09b80fa57..f2375bcc4 100644
--- a/lib/pleroma/web/activity_pub/utils.ex
+++ b/lib/pleroma/web/activity_pub/utils.ex
@@ -6,6 +6,7 @@ defmodule Pleroma.Web.ActivityPub.Utils do
   alias Ecto.Changeset
   alias Ecto.UUID
   alias Pleroma.Activity
+  alias Pleroma.Config
   alias Pleroma.Notification
   alias Pleroma.Object
   alias Pleroma.Repo
@@ -169,8 +170,11 @@ def create_context(context) do
   Enqueues an activity for federation if it's local
   """
   @spec maybe_federate(any()) :: :ok
-  def maybe_federate(%Activity{local: true} = activity) do
-    if Pleroma.Config.get!([:instance, :federating]) do
+  def maybe_federate(%Activity{local: true, data: %{"type" => type}} = activity) do
+    outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
+
+    with true <- Config.get!([:instance, :federating]),
+         true <- type != "Block" || outgoing_blocks do
       Pleroma.Web.Federator.publish(activity)
     end
 
diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
index 9f1fd3aeb..9821173d0 100644
--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
@@ -844,15 +844,20 @@ def status_show(conn, %{"id" => id}) do
   end
 
   def status_update(%{assigns: %{user: admin}} = conn, %{"id" => id} = params) do
+    params =
+      params
+      |> Map.take(["sensitive", "visibility"])
+      |> Map.new(fn {key, value} -> {String.to_existing_atom(key), value} end)
+
     with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
-      {:ok, sensitive} = Ecto.Type.cast(:boolean, params["sensitive"])
+      {:ok, sensitive} = Ecto.Type.cast(:boolean, params[:sensitive])
 
       ModerationLog.insert_log(%{
         action: "status_update",
         actor: admin,
         subject: activity,
         sensitive: sensitive,
-        visibility: params["visibility"]
+        visibility: params[:visibility]
       })
 
       conn
diff --git a/lib/pleroma/web/api_spec/operations/status_operation.ex b/lib/pleroma/web/api_spec/operations/status_operation.ex
new file mode 100644
index 000000000..a6bb87560
--- /dev/null
+++ b/lib/pleroma/web/api_spec/operations/status_operation.ex
@@ -0,0 +1,499 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ApiSpec.StatusOperation do
+  alias OpenApiSpex.Operation
+  alias OpenApiSpex.Schema
+  alias Pleroma.Web.ApiSpec.AccountOperation
+  alias Pleroma.Web.ApiSpec.Schemas.ApiError
+  alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
+  alias Pleroma.Web.ApiSpec.Schemas.FlakeID
+  alias Pleroma.Web.ApiSpec.Schemas.ScheduledStatus
+  alias Pleroma.Web.ApiSpec.Schemas.Status
+  alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope
+
+  import Pleroma.Web.ApiSpec.Helpers
+
+  def open_api_operation(action) do
+    operation = String.to_existing_atom("#{action}_operation")
+    apply(__MODULE__, operation, [])
+  end
+
+  def index_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Get multiple statuses by IDs",
+      security: [%{"oAuth" => ["read:statuses"]}],
+      parameters: [
+        Operation.parameter(
+          :ids,
+          :query,
+          %Schema{type: :array, items: FlakeID},
+          "Array of status IDs"
+        )
+      ],
+      operationId: "StatusController.index",
+      responses: %{
+        200 => Operation.response("Array of Status", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  def create_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Publish new status",
+      security: [%{"oAuth" => ["write:statuses"]}],
+      description: "Post a new status",
+      operationId: "StatusController.create",
+      requestBody: request_body("Parameters", create_request(), required: true),
+      responses: %{
+        200 =>
+          Operation.response(
+            "Status. When `scheduled_at` is present, ScheduledStatus is returned instead",
+            "application/json",
+            %Schema{oneOf: [Status, ScheduledStatus]}
+          ),
+        422 => Operation.response("Bad Request", "application/json", ApiError)
+      }
+    }
+  end
+
+  def show_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "View specific status",
+      description: "View information about a status",
+      operationId: "StatusController.show",
+      security: [%{"oAuth" => ["read:statuses"]}],
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def delete_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Delete status",
+      security: [%{"oAuth" => ["write:statuses"]}],
+      description: "Delete one of your own statuses",
+      operationId: "StatusController.delete",
+      parameters: [id_param()],
+      responses: %{
+        200 => empty_object_response(),
+        403 => Operation.response("Forbidden", "application/json", ApiError),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def reblog_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Boost",
+      security: [%{"oAuth" => ["write:statuses"]}],
+      description: "Share a status",
+      operationId: "StatusController.reblog",
+      parameters: [id_param()],
+      requestBody:
+        request_body("Parameters", %Schema{
+          type: :object,
+          properties: %{
+            visibility: %Schema{allOf: [VisibilityScope], default: "public"}
+          }
+        }),
+      responses: %{
+        200 => status_response(),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def unreblog_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Undo boost",
+      security: [%{"oAuth" => ["write:statuses"]}],
+      description: "Undo a reshare of a status",
+      operationId: "StatusController.unreblog",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def favourite_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Favourite",
+      security: [%{"oAuth" => ["write:favourites"]}],
+      description: "Add a status to your favourites list",
+      operationId: "StatusController.favourite",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def unfavourite_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Undo favourite",
+      security: [%{"oAuth" => ["write:favourites"]}],
+      description: "Remove a status from your favourites list",
+      operationId: "StatusController.unfavourite",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def pin_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Pin to profile",
+      security: [%{"oAuth" => ["write:accounts"]}],
+      description: "Feature one of your own public statuses at the top of your profile",
+      operationId: "StatusController.pin",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        400 => Operation.response("Error", "application/json", ApiError)
+      }
+    }
+  end
+
+  def unpin_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Unpin to profile",
+      security: [%{"oAuth" => ["write:accounts"]}],
+      description: "Unfeature a status from the top of your profile",
+      operationId: "StatusController.unpin",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        400 => Operation.response("Error", "application/json", ApiError)
+      }
+    }
+  end
+
+  def bookmark_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Bookmark",
+      security: [%{"oAuth" => ["write:bookmarks"]}],
+      description: "Privately bookmark a status",
+      operationId: "StatusController.bookmark",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response()
+      }
+    }
+  end
+
+  def unbookmark_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Undo bookmark",
+      security: [%{"oAuth" => ["write:bookmarks"]}],
+      description: "Remove a status from your private bookmarks",
+      operationId: "StatusController.unbookmark",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response()
+      }
+    }
+  end
+
+  def mute_conversation_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Mute conversation",
+      security: [%{"oAuth" => ["write:mutes"]}],
+      description: "Do not receive notifications for the thread that this status is part of.",
+      operationId: "StatusController.mute_conversation",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        400 => Operation.response("Error", "application/json", ApiError)
+      }
+    }
+  end
+
+  def unmute_conversation_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Unmute conversation",
+      security: [%{"oAuth" => ["write:mutes"]}],
+      description:
+        "Start receiving notifications again for the thread that this status is part of",
+      operationId: "StatusController.unmute_conversation",
+      parameters: [id_param()],
+      responses: %{
+        200 => status_response(),
+        400 => Operation.response("Error", "application/json", ApiError)
+      }
+    }
+  end
+
+  def card_operation do
+    %Operation{
+      tags: ["Statuses"],
+      deprecated: true,
+      summary: "Preview card",
+      description: "Deprecated in favor of card property inlined on Status entity",
+      operationId: "StatusController.card",
+      parameters: [id_param()],
+      security: [%{"oAuth" => ["read:statuses"]}],
+      responses: %{
+        200 =>
+          Operation.response("Card", "application/json", %Schema{
+            type: :object,
+            nullable: true,
+            properties: %{
+              type: %Schema{type: :string, enum: ["link", "photo", "video", "rich"]},
+              provider_name: %Schema{type: :string, nullable: true},
+              provider_url: %Schema{type: :string, format: :uri},
+              url: %Schema{type: :string, format: :uri},
+              image: %Schema{type: :string, nullable: true, format: :uri},
+              title: %Schema{type: :string},
+              description: %Schema{type: :string}
+            }
+          })
+      }
+    }
+  end
+
+  def favourited_by_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Favourited by",
+      description: "View who favourited a given status",
+      operationId: "StatusController.favourited_by",
+      security: [%{"oAuth" => ["read:accounts"]}],
+      parameters: [id_param()],
+      responses: %{
+        200 =>
+          Operation.response(
+            "Array of Accounts",
+            "application/json",
+            AccountOperation.array_of_accounts()
+          ),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def reblogged_by_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Boosted by",
+      description: "View who boosted a given status",
+      operationId: "StatusController.reblogged_by",
+      security: [%{"oAuth" => ["read:accounts"]}],
+      parameters: [id_param()],
+      responses: %{
+        200 =>
+          Operation.response(
+            "Array of Accounts",
+            "application/json",
+            AccountOperation.array_of_accounts()
+          ),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def context_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Parent and child statuses",
+      description: "View statuses above and below this status in the thread",
+      operationId: "StatusController.context",
+      security: [%{"oAuth" => ["read:statuses"]}],
+      parameters: [id_param()],
+      responses: %{
+        200 => Operation.response("Context", "application/json", context())
+      }
+    }
+  end
+
+  def favourites_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Favourited statuses",
+      description: "Statuses the user has favourited",
+      operationId: "StatusController.favourites",
+      parameters: pagination_params(),
+      security: [%{"oAuth" => ["read:favourites"]}],
+      responses: %{
+        200 => Operation.response("Array of Statuses", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  def bookmarks_operation do
+    %Operation{
+      tags: ["Statuses"],
+      summary: "Bookmarked statuses",
+      description: "Statuses the user has bookmarked",
+      operationId: "StatusController.bookmarks",
+      parameters: [
+        Operation.parameter(:with_relationships, :query, BooleanLike, "Include relationships")
+        | pagination_params()
+      ],
+      security: [%{"oAuth" => ["read:bookmarks"]}],
+      responses: %{
+        200 => Operation.response("Array of Statuses", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  defp array_of_statuses do
+    %Schema{type: :array, items: Status, example: [Status.schema().example]}
+  end
+
+  defp create_request do
+    %Schema{
+      title: "StatusCreateRequest",
+      type: :object,
+      properties: %{
+        status: %Schema{
+          type: :string,
+          description:
+            "Text content of the status. If `media_ids` is provided, this becomes optional. Attaching a `poll` is optional while `status` is provided."
+        },
+        media_ids: %Schema{
+          type: :array,
+          items: %Schema{type: :string},
+          description: "Array of Attachment ids to be attached as media."
+        },
+        poll: %Schema{
+          type: :object,
+          required: [:options],
+          properties: %{
+            options: %Schema{
+              type: :array,
+              items: %Schema{type: :string},
+              description: "Array of possible answers. Must be provided with `poll[expires_in]`."
+            },
+            expires_in: %Schema{
+              type: :integer,
+              description:
+                "Duration the poll should be open, in seconds. Must be provided with `poll[options]`"
+            },
+            multiple: %Schema{type: :boolean, description: "Allow multiple choices?"},
+            hide_totals: %Schema{
+              type: :boolean,
+              description: "Hide vote counts until the poll ends?"
+            }
+          }
+        },
+        in_reply_to_id: %Schema{
+          allOf: [FlakeID],
+          description: "ID of the status being replied to, if status is a reply"
+        },
+        sensitive: %Schema{
+          type: :boolean,
+          description: "Mark status and attached media as sensitive?"
+        },
+        spoiler_text: %Schema{
+          type: :string,
+          description:
+            "Text to be shown as a warning or subject before the actual content. Statuses are generally collapsed behind this field."
+        },
+        scheduled_at: %Schema{
+          type: :string,
+          format: :"date-time",
+          nullable: true,
+          description:
+            "ISO 8601 Datetime at which to schedule a status. Providing this paramter will cause ScheduledStatus to be returned instead of Status. Must be at least 5 minutes in the future."
+        },
+        language: %Schema{type: :string, description: "ISO 639 language code for this status."},
+        # Pleroma-specific properties:
+        preview: %Schema{
+          type: :boolean,
+          description:
+            "If set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example"
+        },
+        content_type: %Schema{
+          type: :string,
+          description:
+            "The MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint."
+        },
+        to: %Schema{
+          type: :array,
+          items: %Schema{type: :string},
+          description:
+            "A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply"
+        },
+        visibility: %Schema{
+          anyOf: [
+            VisibilityScope,
+            %Schema{type: :string, description: "`list:LIST_ID`", example: "LIST:123"}
+          ],
+          description:
+            "Visibility of the posted status. Besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`"
+        },
+        expires_in: %Schema{
+          type: :integer,
+          description:
+            "The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour."
+        },
+        in_reply_to_conversation_id: %Schema{
+          type: :string,
+          description:
+            "Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`."
+        }
+      },
+      example: %{
+        "status" => "What time is it?",
+        "sensitive" => "false",
+        "poll" => %{
+          "options" => ["Cofe", "Adventure"],
+          "expires_in" => 420
+        }
+      }
+    }
+  end
+
+  defp id_param do
+    Operation.parameter(:id, :path, FlakeID, "Status ID",
+      example: "9umDrYheeY451cQnEe",
+      required: true
+    )
+  end
+
+  defp status_response do
+    Operation.response("Status", "application/json", Status)
+  end
+
+  defp context do
+    %Schema{
+      title: "StatusContext",
+      description:
+        "Represents the tree around a given status. Used for reconstructing threads of statuses.",
+      type: :object,
+      required: [:ancestors, :descendants],
+      properties: %{
+        ancestors: array_of_statuses(),
+        descendants: array_of_statuses()
+      },
+      example: %{
+        "ancestors" => [Status.schema().example],
+        "descendants" => [Status.schema().example]
+      }
+    }
+  end
+end
diff --git a/lib/pleroma/web/api_spec/operations/timeline_operation.ex b/lib/pleroma/web/api_spec/operations/timeline_operation.ex
new file mode 100644
index 000000000..1b89035d4
--- /dev/null
+++ b/lib/pleroma/web/api_spec/operations/timeline_operation.ex
@@ -0,0 +1,199 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ApiSpec.TimelineOperation do
+  alias OpenApiSpex.Operation
+  alias OpenApiSpex.Schema
+  alias Pleroma.Web.ApiSpec.Schemas.ApiError
+  alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
+  alias Pleroma.Web.ApiSpec.Schemas.Status
+  alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope
+
+  import Pleroma.Web.ApiSpec.Helpers
+
+  def open_api_operation(action) do
+    operation = String.to_existing_atom("#{action}_operation")
+    apply(__MODULE__, operation, [])
+  end
+
+  def home_operation do
+    %Operation{
+      tags: ["Timelines"],
+      summary: "Home timeline",
+      description: "View statuses from followed users",
+      security: [%{"oAuth" => ["read:statuses"]}],
+      parameters: [
+        local_param(),
+        with_muted_param(),
+        exclude_visibilities_param(),
+        reply_visibility_param(),
+        with_relationships_param() | pagination_params()
+      ],
+      operationId: "TimelineController.home",
+      responses: %{
+        200 => Operation.response("Array of Status", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  def direct_operation do
+    %Operation{
+      tags: ["Timelines"],
+      summary: "Direct timeline",
+      description:
+        "View statuses with a “direct” privacy, from your account or in your notifications",
+      deprecated: true,
+      parameters: pagination_params(),
+      security: [%{"oAuth" => ["read:statuses"]}],
+      operationId: "TimelineController.direct",
+      responses: %{
+        200 => Operation.response("Array of Status", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  def public_operation do
+    %Operation{
+      tags: ["Timelines"],
+      summary: "Public timeline",
+      security: [%{"oAuth" => ["read:statuses"]}],
+      parameters: [
+        local_param(),
+        only_media_param(),
+        with_muted_param(),
+        exclude_visibilities_param(),
+        reply_visibility_param(),
+        with_relationships_param() | pagination_params()
+      ],
+      operationId: "TimelineController.public",
+      responses: %{
+        200 => Operation.response("Array of Status", "application/json", array_of_statuses()),
+        401 => Operation.response("Error", "application/json", ApiError)
+      }
+    }
+  end
+
+  def hashtag_operation do
+    %Operation{
+      tags: ["Timelines"],
+      summary: "Hashtag timeline",
+      description: "View public statuses containing the given hashtag",
+      security: [%{"oAuth" => ["read:statuses"]}],
+      parameters: [
+        Operation.parameter(
+          :tag,
+          :path,
+          %Schema{type: :string},
+          "Content of a #hashtag, not including # symbol.",
+          required: true
+        ),
+        Operation.parameter(
+          :any,
+          :query,
+          %Schema{type: :array, items: %Schema{type: :string}},
+          "Statuses that also includes any of these tags"
+        ),
+        Operation.parameter(
+          :all,
+          :query,
+          %Schema{type: :array, items: %Schema{type: :string}},
+          "Statuses that also includes all of these tags"
+        ),
+        Operation.parameter(
+          :none,
+          :query,
+          %Schema{type: :array, items: %Schema{type: :string}},
+          "Statuses that do not include these tags"
+        ),
+        local_param(),
+        only_media_param(),
+        with_muted_param(),
+        exclude_visibilities_param(),
+        with_relationships_param() | pagination_params()
+      ],
+      operationId: "TimelineController.hashtag",
+      responses: %{
+        200 => Operation.response("Array of Status", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  def list_operation do
+    %Operation{
+      tags: ["Timelines"],
+      summary: "List timeline",
+      description: "View statuses in the given list timeline",
+      security: [%{"oAuth" => ["read:lists"]}],
+      parameters: [
+        Operation.parameter(
+          :list_id,
+          :path,
+          %Schema{type: :string},
+          "Local ID of the list in the database",
+          required: true
+        ),
+        with_muted_param(),
+        exclude_visibilities_param(),
+        with_relationships_param() | pagination_params()
+      ],
+      operationId: "TimelineController.list",
+      responses: %{
+        200 => Operation.response("Array of Status", "application/json", array_of_statuses())
+      }
+    }
+  end
+
+  defp array_of_statuses do
+    %Schema{
+      title: "ArrayOfStatuses",
+      type: :array,
+      items: Status,
+      example: [Status.schema().example]
+    }
+  end
+
+  defp with_relationships_param do
+    Operation.parameter(:with_relationships, :query, BooleanLike, "Include relationships")
+  end
+
+  defp local_param do
+    Operation.parameter(
+      :local,
+      :query,
+      %Schema{allOf: [BooleanLike], default: false},
+      "Show only local statuses?"
+    )
+  end
+
+  defp with_muted_param do
+    Operation.parameter(:with_muted, :query, BooleanLike, "Includeactivities by muted users")
+  end
+
+  defp exclude_visibilities_param do
+    Operation.parameter(
+      :exclude_visibilities,
+      :query,
+      %Schema{type: :array, items: VisibilityScope},
+      "Exclude the statuses with the given visibilities"
+    )
+  end
+
+  defp reply_visibility_param do
+    Operation.parameter(
+      :reply_visibility,
+      :query,
+      %Schema{type: :string, enum: ["following", "self"]},
+      "Filter replies. Possible values: without parameter (default) shows all replies, `following` - replies directed to you or users you follow, `self` - replies directed to you."
+    )
+  end
+
+  defp only_media_param do
+    Operation.parameter(
+      :only_media,
+      :query,
+      %Schema{allOf: [BooleanLike], default: false},
+      "Show only statuses with media attached?"
+    )
+  end
+end
diff --git a/lib/pleroma/web/api_spec/schemas/status.ex b/lib/pleroma/web/api_spec/schemas/status.ex
index 2572c9641..8b87cb25b 100644
--- a/lib/pleroma/web/api_spec/schemas/status.ex
+++ b/lib/pleroma/web/api_spec/schemas/status.ex
@@ -19,60 +19,127 @@ defmodule Pleroma.Web.ApiSpec.Schemas.Status do
     description: "Response schema for a status",
     type: :object,
     properties: %{
-      account: Account,
+      account: %Schema{allOf: [Account], description: "The account that authored this status"},
       application: %Schema{
+        description: "The application used to post this status",
         type: :object,
         properties: %{
           name: %Schema{type: :string},
           website: %Schema{type: :string, nullable: true, format: :uri}
         }
       },
-      bookmarked: %Schema{type: :boolean},
+      bookmarked: %Schema{type: :boolean, description: "Have you bookmarked this status?"},
       card: %Schema{
         type: :object,
         nullable: true,
+        description: "Preview card for links included within status content",
+        required: [:url, :title, :description, :type],
         properties: %{
-          type: %Schema{type: :string, enum: ["link", "photo", "video", "rich"]},
-          provider_name: %Schema{type: :string, nullable: true},
-          provider_url: %Schema{type: :string, format: :uri},
-          url: %Schema{type: :string, format: :uri},
-          image: %Schema{type: :string, nullable: true, format: :uri},
-          title: %Schema{type: :string},
-          description: %Schema{type: :string}
+          type: %Schema{
+            type: :string,
+            enum: ["link", "photo", "video", "rich"],
+            description: "The type of the preview card"
+          },
+          provider_name: %Schema{
+            type: :string,
+            nullable: true,
+            description: "The provider of the original resource"
+          },
+          provider_url: %Schema{
+            type: :string,
+            format: :uri,
+            description: "A link to the provider of the original resource"
+          },
+          url: %Schema{type: :string, format: :uri, description: "Location of linked resource"},
+          image: %Schema{
+            type: :string,
+            nullable: true,
+            format: :uri,
+            description: "Preview thumbnail"
+          },
+          title: %Schema{type: :string, description: "Title of linked resource"},
+          description: %Schema{type: :string, description: "Description of preview"}
         }
       },
-      content: %Schema{type: :string, format: :html},
-      created_at: %Schema{type: :string, format: "date-time"},
-      emojis: %Schema{type: :array, items: Emoji},
-      favourited: %Schema{type: :boolean},
-      favourites_count: %Schema{type: :integer},
+      content: %Schema{type: :string, format: :html, description: "HTML-encoded status content"},
+      created_at: %Schema{
+        type: :string,
+        format: "date-time",
+        description: "The date when this status was created"
+      },
+      emojis: %Schema{
+        type: :array,
+        items: Emoji,
+        description: "Custom emoji to be used when rendering status content"
+      },
+      favourited: %Schema{type: :boolean, description: "Have you favourited this status?"},
+      favourites_count: %Schema{
+        type: :integer,
+        description: "How many favourites this status has received"
+      },
       id: FlakeID,
-      in_reply_to_account_id: %Schema{type: :string, nullable: true},
-      in_reply_to_id: %Schema{type: :string, nullable: true},
-      language: %Schema{type: :string, nullable: true},
+      in_reply_to_account_id: %Schema{
+        allOf: [FlakeID],
+        nullable: true,
+        description: "ID of the account being replied to"
+      },
+      in_reply_to_id: %Schema{
+        allOf: [FlakeID],
+        nullable: true,
+        description: "ID of the status being replied"
+      },
+      language: %Schema{
+        type: :string,
+        nullable: true,
+        description: "Primary language of this status"
+      },
       media_attachments: %Schema{
         type: :array,
-        items: Attachment
+        items: Attachment,
+        description: "Media that is attached to this status"
       },
       mentions: %Schema{
         type: :array,
+        description: "Mentions of users within the status content",
         items: %Schema{
           type: :object,
           properties: %{
-            id: %Schema{type: :string},
-            acct: %Schema{type: :string},
-            username: %Schema{type: :string},
-            url: %Schema{type: :string, format: :uri}
+            id: %Schema{allOf: [FlakeID], description: "The account id of the mentioned user"},
+            acct: %Schema{
+              type: :string,
+              description:
+                "The webfinger acct: URI of the mentioned user. Equivalent to `username` for local users, or `username@domain` for remote users."
+            },
+            username: %Schema{type: :string, description: "The username of the mentioned user"},
+            url: %Schema{
+              type: :string,
+              format: :uri,
+              description: "The location of the mentioned user's profile"
+            }
           }
         }
       },
-      muted: %Schema{type: :boolean},
-      pinned: %Schema{type: :boolean},
+      muted: %Schema{
+        type: :boolean,
+        description: "Have you muted notifications for this status's conversation?"
+      },
+      pinned: %Schema{
+        type: :boolean,
+        description: "Have you pinned this status? Only appears if the status is pinnable."
+      },
       pleroma: %Schema{
         type: :object,
         properties: %{
-          content: %Schema{type: :object, additionalProperties: %Schema{type: :string}},
-          conversation_id: %Schema{type: :integer},
+          content: %Schema{
+            type: :object,
+            additionalProperties: %Schema{type: :string},
+            description:
+              "A map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`"
+          },
+          conversation_id: %Schema{
+            type: :integer,
+            description: "The ID of the AP context the status is associated with (if any)"
+          },
           direct_conversation_id: %Schema{
             type: :integer,
             nullable: true,
@@ -81,6 +148,8 @@ defmodule Pleroma.Web.ApiSpec.Schemas.Status do
           },
           emoji_reactions: %Schema{
             type: :array,
+            description:
+              "A list with emoji / reaction maps. Contains no information about the reacting users, for that use the /statuses/:id/reactions endpoint.",
             items: %Schema{
               type: :object,
               properties: %{
@@ -90,27 +159,74 @@ defmodule Pleroma.Web.ApiSpec.Schemas.Status do
               }
             }
           },
-          expires_at: %Schema{type: :string, format: "date-time", nullable: true},
-          in_reply_to_account_acct: %Schema{type: :string, nullable: true},
-          local: %Schema{type: :boolean},
-          spoiler_text: %Schema{type: :object, additionalProperties: %Schema{type: :string}},
-          thread_muted: %Schema{type: :boolean}
+          expires_at: %Schema{
+            type: :string,
+            format: "date-time",
+            nullable: true,
+            description:
+              "A datetime (ISO 8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire"
+          },
+          in_reply_to_account_acct: %Schema{
+            type: :string,
+            nullable: true,
+            description: "The `acct` property of User entity for replied user (if any)"
+          },
+          local: %Schema{
+            type: :boolean,
+            description: "`true` if the post was made on the local instance"
+          },
+          spoiler_text: %Schema{
+            type: :object,
+            additionalProperties: %Schema{type: :string},
+            description:
+              "A map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`."
+          },
+          thread_muted: %Schema{
+            type: :boolean,
+            description: "`true` if the thread the post belongs to is muted"
+          }
         }
       },
-      poll: %Schema{type: Poll, nullable: true},
+      poll: %Schema{allOf: [Poll], nullable: true, description: "The poll attached to the status"},
       reblog: %Schema{
         allOf: [%OpenApiSpex.Reference{"$ref": "#/components/schemas/Status"}],
-        nullable: true
+        nullable: true,
+        description: "The status being reblogged"
+      },
+      reblogged: %Schema{type: :boolean, description: "Have you boosted this status?"},
+      reblogs_count: %Schema{
+        type: :integer,
+        description: "How many boosts this status has received"
+      },
+      replies_count: %Schema{
+        type: :integer,
+        description: "How many replies this status has received"
+      },
+      sensitive: %Schema{
+        type: :boolean,
+        description: "Is this status marked as sensitive content?"
+      },
+      spoiler_text: %Schema{
+        type: :string,
+        description:
+          "Subject or summary line, below which status content is collapsed until expanded"
       },
-      reblogged: %Schema{type: :boolean},
-      reblogs_count: %Schema{type: :integer},
-      replies_count: %Schema{type: :integer},
-      sensitive: %Schema{type: :boolean},
-      spoiler_text: %Schema{type: :string},
       tags: %Schema{type: :array, items: Tag},
-      uri: %Schema{type: :string, format: :uri},
-      url: %Schema{type: :string, nullable: true, format: :uri},
-      visibility: VisibilityScope
+      uri: %Schema{
+        type: :string,
+        format: :uri,
+        description: "URI of the status used for federation"
+      },
+      url: %Schema{
+        type: :string,
+        nullable: true,
+        format: :uri,
+        description: "A link to the status's HTML representation"
+      },
+      visibility: %Schema{
+        allOf: [VisibilityScope],
+        description: "Visibility of this status"
+      }
     },
     example: %{
       "account" => %{
diff --git a/lib/pleroma/web/api_spec/schemas/visibility_scope.ex b/lib/pleroma/web/api_spec/schemas/visibility_scope.ex
index 8c81a4d73..831734e27 100644
--- a/lib/pleroma/web/api_spec/schemas/visibility_scope.ex
+++ b/lib/pleroma/web/api_spec/schemas/visibility_scope.ex
@@ -9,6 +9,6 @@ defmodule Pleroma.Web.ApiSpec.Schemas.VisibilityScope do
     title: "VisibilityScope",
     description: "Status visibility",
     type: :string,
-    enum: ["public", "unlisted", "private", "direct"]
+    enum: ["public", "unlisted", "private", "direct", "list"]
   })
 end
diff --git a/lib/pleroma/web/auth/totp_authenticator.ex b/lib/pleroma/web/auth/totp_authenticator.ex
index 98aca9a51..04e489c83 100644
--- a/lib/pleroma/web/auth/totp_authenticator.ex
+++ b/lib/pleroma/web/auth/totp_authenticator.ex
@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Web.Auth.TOTPAuthenticator do
-  alias Comeonin.Pbkdf2
   alias Pleroma.MFA
   alias Pleroma.MFA.TOTP
   alias Pleroma.User
@@ -31,7 +30,7 @@ def verify_recovery_code(
         code
       )
       when is_list(codes) and is_binary(code) do
-    hash_code = Enum.find(codes, fn hash -> Pbkdf2.checkpw(code, hash) end)
+    hash_code = Enum.find(codes, fn hash -> Pbkdf2.verify_pass(code, hash) end)
 
     if hash_code do
       MFA.invalidate_backup_code(user, hash_code)
diff --git a/lib/pleroma/web/common_api/activity_draft.ex b/lib/pleroma/web/common_api/activity_draft.ex
index 244cf2be5..3f1a50b96 100644
--- a/lib/pleroma/web/common_api/activity_draft.ex
+++ b/lib/pleroma/web/common_api/activity_draft.ex
@@ -58,16 +58,16 @@ def create(user, params) do
   end
 
   defp put_params(draft, params) do
-    params = Map.put_new(params, "in_reply_to_status_id", params["in_reply_to_id"])
+    params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
     %__MODULE__{draft | params: params}
   end
 
-  defp status(%{params: %{"status" => status}} = draft) do
+  defp status(%{params: %{status: status}} = draft) do
     %__MODULE__{draft | status: String.trim(status)}
   end
 
   defp summary(%{params: params} = draft) do
-    %__MODULE__{draft | summary: Map.get(params, "spoiler_text", "")}
+    %__MODULE__{draft | summary: Map.get(params, :spoiler_text, "")}
   end
 
   defp full_payload(%{status: status, summary: summary} = draft) do
@@ -84,20 +84,20 @@ defp attachments(%{params: params} = draft) do
     %__MODULE__{draft | attachments: attachments}
   end
 
-  defp in_reply_to(%{params: %{"in_reply_to_status_id" => ""}} = draft), do: draft
+  defp in_reply_to(%{params: %{in_reply_to_status_id: ""}} = draft), do: draft
 
-  defp in_reply_to(%{params: %{"in_reply_to_status_id" => id}} = draft) when is_binary(id) do
+  defp in_reply_to(%{params: %{in_reply_to_status_id: id}} = draft) when is_binary(id) do
     %__MODULE__{draft | in_reply_to: Activity.get_by_id(id)}
   end
 
-  defp in_reply_to(%{params: %{"in_reply_to_status_id" => %Activity{} = in_reply_to}} = draft) do
+  defp in_reply_to(%{params: %{in_reply_to_status_id: %Activity{} = in_reply_to}} = draft) do
     %__MODULE__{draft | in_reply_to: in_reply_to}
   end
 
   defp in_reply_to(draft), do: draft
 
   defp in_reply_to_conversation(draft) do
-    in_reply_to_conversation = Participation.get(draft.params["in_reply_to_conversation_id"])
+    in_reply_to_conversation = Participation.get(draft.params[:in_reply_to_conversation_id])
     %__MODULE__{draft | in_reply_to_conversation: in_reply_to_conversation}
   end
 
@@ -112,7 +112,7 @@ defp visibility(%{params: params} = draft) do
   end
 
   defp expires_at(draft) do
-    case CommonAPI.check_expiry_date(draft.params["expires_in"]) do
+    case CommonAPI.check_expiry_date(draft.params[:expires_in]) do
       {:ok, expires_at} -> %__MODULE__{draft | expires_at: expires_at}
       {:error, message} -> add_error(draft, message)
     end
@@ -144,7 +144,7 @@ defp to_and_cc(draft) do
     addressed_users =
       draft.mentions
       |> Enum.map(fn {_, mentioned_user} -> mentioned_user.ap_id end)
-      |> Utils.get_addressed_users(draft.params["to"])
+      |> Utils.get_addressed_users(draft.params[:to])
 
     {to, cc} =
       Utils.get_to_and_cc(
@@ -164,7 +164,7 @@ defp context(draft) do
   end
 
   defp sensitive(draft) do
-    sensitive = draft.params["sensitive"] || Enum.member?(draft.tags, {"#nsfw", "nsfw"})
+    sensitive = draft.params[:sensitive] || Enum.member?(draft.tags, {"#nsfw", "nsfw"})
     %__MODULE__{draft | sensitive: sensitive}
   end
 
@@ -191,7 +191,7 @@ defp object(draft) do
   end
 
   defp preview?(draft) do
-    preview? = Pleroma.Web.ControllerHelper.truthy_param?(draft.params["preview"])
+    preview? = Pleroma.Web.ControllerHelper.truthy_param?(draft.params[:preview])
     %__MODULE__{draft | preview?: preview?}
   end
 
diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
index 11f19a9b9..664175a4f 100644
--- a/lib/pleroma/web/common_api/common_api.ex
+++ b/lib/pleroma/web/common_api/common_api.ex
@@ -147,19 +147,18 @@ def delete(activity_id, user) do
   end
 
   def repeat(id, user, params \\ %{}) do
-    with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
-           {:find_activity, Activity.get_by_id(id)},
-         object <- Object.normalize(activity),
-         announce_activity <- Utils.get_existing_announce(user.ap_id, object),
-         public <- public_announce?(object, params) do
+    with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id) do
+      object = Object.normalize(activity)
+      announce_activity = Utils.get_existing_announce(user.ap_id, object)
+      public = public_announce?(object, params)
+
       if announce_activity do
         {:ok, announce_activity, object}
       else
         ActivityPub.announce(user, object, nil, true, public)
       end
     else
-      {:find_activity, _} -> {:error, :not_found}
-      _ -> {:error, dgettext("errors", "Could not repeat")}
+      _ -> {:error, :not_found}
     end
   end
 
@@ -317,7 +316,7 @@ defp normalize_and_validate_choices(choices, object) do
     end
   end
 
-  def public_announce?(_, %{"visibility" => visibility})
+  def public_announce?(_, %{visibility: visibility})
       when visibility in ~w{public unlisted private direct},
       do: visibility in ~w(public unlisted)
 
@@ -327,11 +326,11 @@ def public_announce?(object, _) do
 
   def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}
 
-  def get_visibility(%{"visibility" => visibility}, in_reply_to, _)
+  def get_visibility(%{visibility: visibility}, in_reply_to, _)
       when visibility in ~w{public unlisted private direct},
       do: {visibility, get_replied_to_visibility(in_reply_to)}
 
-  def get_visibility(%{"visibility" => "list:" <> list_id}, in_reply_to, _) do
+  def get_visibility(%{visibility: "list:" <> list_id}, in_reply_to, _) do
     visibility = {:list, String.to_integer(list_id)}
     {visibility, get_replied_to_visibility(in_reply_to)}
   end
@@ -389,7 +388,7 @@ def listen(user, %{"title" => _} = data) do
     end
   end
 
-  def post(user, %{"status" => _} = data) do
+  def post(user, %{status: _} = data) do
     with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do
       draft.changes
       |> ActivityPub.create(draft.preview?)
@@ -498,11 +497,11 @@ def update_activity_scope(activity_id, opts \\ %{}) do
     end
   end
 
-  defp toggle_sensitive(activity, %{"sensitive" => sensitive}) when sensitive in ~w(true false) do
-    toggle_sensitive(activity, %{"sensitive" => String.to_existing_atom(sensitive)})
+  defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
+    toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
   end
 
-  defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sensitive})
+  defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
        when is_boolean(sensitive) do
     new_data = Map.put(object.data, "sensitive", sensitive)
 
@@ -516,7 +515,7 @@ defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sen
 
   defp toggle_sensitive(activity, _), do: {:ok, activity}
 
-  defp set_visibility(activity, %{"visibility" => visibility}) do
+  defp set_visibility(activity, %{visibility: visibility}) do
     Utils.update_activity_visibility(activity, visibility)
   end
 
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index 47fd6a523..ef7a9d967 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -22,11 +22,11 @@ defmodule Pleroma.Web.CommonAPI.Utils do
   require Logger
   require Pleroma.Constants
 
-  def attachments_from_ids(%{"media_ids" => ids, "descriptions" => desc} = _) do
+  def attachments_from_ids(%{media_ids: ids, descriptions: desc}) do
     attachments_from_ids_descs(ids, desc)
   end
 
-  def attachments_from_ids(%{"media_ids" => ids} = _) do
+  def attachments_from_ids(%{media_ids: ids}) do
     attachments_from_ids_no_descs(ids)
   end
 
@@ -37,11 +37,11 @@ def attachments_from_ids_no_descs([]), do: []
   def attachments_from_ids_no_descs(ids) do
     Enum.map(ids, fn media_id ->
       case Repo.get(Object, media_id) do
-        %Object{data: data} = _ -> data
+        %Object{data: data} -> data
         _ -> nil
       end
     end)
-    |> Enum.filter(& &1)
+    |> Enum.reject(&is_nil/1)
   end
 
   def attachments_from_ids_descs([], _), do: []
@@ -51,14 +51,14 @@ def attachments_from_ids_descs(ids, descs_str) do
 
     Enum.map(ids, fn media_id ->
       case Repo.get(Object, media_id) do
-        %Object{data: data} = _ ->
+        %Object{data: data} ->
           Map.put(data, "name", descs[media_id])
 
         _ ->
           nil
       end
     end)
-    |> Enum.filter(& &1)
+    |> Enum.reject(&is_nil/1)
   end
 
   @spec get_to_and_cc(
@@ -140,7 +140,7 @@ def make_poll_data(%{"poll" => %{"expires_in" => expires_in}} = data)
     |> make_poll_data()
   end
 
-  def make_poll_data(%{"poll" => %{"options" => options, "expires_in" => expires_in}} = data)
+  def make_poll_data(%{poll: %{options: options, expires_in: expires_in}} = data)
       when is_list(options) do
     limits = Pleroma.Config.get([:instance, :poll_limits])
 
@@ -163,7 +163,7 @@ def make_poll_data(%{"poll" => %{"options" => options, "expires_in" => expires_i
         |> DateTime.add(expires_in)
         |> DateTime.to_iso8601()
 
-      key = if truthy_param?(data["poll"]["multiple"]), do: "anyOf", else: "oneOf"
+      key = if truthy_param?(data.poll[:multiple]), do: "anyOf", else: "oneOf"
       poll = %{"type" => "Question", key => option_notes, "closed" => end_time}
 
       {:ok, {poll, emoji}}
@@ -213,7 +213,7 @@ def make_content_html(
       |> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
       |> truthy_param?()
 
-    content_type = get_content_type(data["content_type"])
+    content_type = get_content_type(data[:content_type])
 
     options =
       if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
diff --git a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
index 12e3ba15e..25e499a77 100644
--- a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
+++ b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
@@ -24,6 +24,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
   alias Pleroma.Web.MastodonAPI.AccountView
   alias Pleroma.Web.MastodonAPI.ScheduledActivityView
 
+  plug(Pleroma.Web.ApiSpec.CastAndValidate)
   plug(:skip_plug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug when action in [:index, :show])
 
   @unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}
@@ -97,12 +98,14 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
 
   action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
 
+  defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.StatusOperation
+
   @doc """
   GET `/api/v1/statuses?ids[]=1&ids[]=2`
 
   `ids` query param is required
   """
-  def index(%{assigns: %{user: user}} = conn, %{"ids" => ids} = params) do
+  def index(%{assigns: %{user: user}} = conn, %{ids: ids} = params) do
     limit = 100
 
     activities =
@@ -125,21 +128,29 @@ def index(%{assigns: %{user: user}} = conn, %{"ids" => ids} = params) do
   Creates a scheduled status when `scheduled_at` param is present and it's far enough
   """
   def create(
-        %{assigns: %{user: user}} = conn,
-        %{"status" => _, "scheduled_at" => scheduled_at} = params
+        %{
+          assigns: %{user: user},
+          body_params: %{status: _, scheduled_at: scheduled_at} = params
+        } = conn,
+        _
       )
       when not is_nil(scheduled_at) do
-    params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"])
+    params = Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
+
+    attrs = %{
+      params: Map.new(params, fn {key, value} -> {to_string(key), value} end),
+      scheduled_at: scheduled_at
+    }
 
     with {:far_enough, true} <- {:far_enough, ScheduledActivity.far_enough?(scheduled_at)},
-         attrs <- %{"params" => params, "scheduled_at" => scheduled_at},
          {:ok, scheduled_activity} <- ScheduledActivity.create(user, attrs) do
       conn
       |> put_view(ScheduledActivityView)
       |> render("show.json", scheduled_activity: scheduled_activity)
     else
       {:far_enough, _} ->
-        create(conn, Map.drop(params, ["scheduled_at"]))
+        params = Map.drop(params, [:scheduled_at])
+        create(%Plug.Conn{conn | body_params: params}, %{})
 
       error ->
         error
@@ -151,8 +162,8 @@ def create(
 
   Creates a regular status
   """
-  def create(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
-    params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"])
+  def create(%{assigns: %{user: user}, body_params: %{status: _} = params} = conn, _) do
+    params = Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
 
     with {:ok, activity} <- CommonAPI.post(user, params) do
       try_render(conn, "show.json",
@@ -169,12 +180,13 @@ def create(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
     end
   end
 
-  def create(%{assigns: %{user: _user}} = conn, %{"media_ids" => _} = params) do
-    create(conn, Map.put(params, "status", ""))
+  def create(%{assigns: %{user: _user}, body_params: %{media_ids: _} = params} = conn, _) do
+    params = Map.put(params, :status, "")
+    create(%Plug.Conn{conn | body_params: params}, %{})
   end
 
   @doc "GET /api/v1/statuses/:id"
-  def show(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def show(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id_with_object(id),
          true <- Visibility.visible_for_user?(activity, user) do
       try_render(conn, "show.json",
@@ -188,7 +200,7 @@ def show(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "DELETE /api/v1/statuses/:id"
-  def delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def delete(%{assigns: %{user: user}} = conn, %{id: id}) do
     with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
       json(conn, %{})
     else
@@ -198,7 +210,7 @@ def delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/reblog"
-  def reblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id} = params) do
+  def reblog(%{assigns: %{user: user}, body_params: params} = conn, %{id: ap_id_or_id}) do
     with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user, params),
          %Activity{} = announce <- Activity.normalize(announce.data) do
       try_render(conn, "show.json", %{activity: announce, for: user, as: :activity})
@@ -206,7 +218,7 @@ def reblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id} = params) do
   end
 
   @doc "POST /api/v1/statuses/:id/unreblog"
-  def unreblog(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
+  def unreblog(%{assigns: %{user: user}} = conn, %{id: activity_id}) do
     with {:ok, _unannounce} <- CommonAPI.unrepeat(activity_id, user),
          %Activity{} = activity <- Activity.get_by_id(activity_id) do
       try_render(conn, "show.json", %{activity: activity, for: user, as: :activity})
@@ -214,7 +226,7 @@ def unreblog(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/favourite"
-  def favourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
+  def favourite(%{assigns: %{user: user}} = conn, %{id: activity_id}) do
     with {:ok, _fav} <- CommonAPI.favorite(user, activity_id),
          %Activity{} = activity <- Activity.get_by_id(activity_id) do
       try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@@ -222,7 +234,7 @@ def favourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/unfavourite"
-  def unfavourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
+  def unfavourite(%{assigns: %{user: user}} = conn, %{id: activity_id}) do
     with {:ok, _unfav} <- CommonAPI.unfavorite(activity_id, user),
          %Activity{} = activity <- Activity.get_by_id(activity_id) do
       try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@@ -230,21 +242,21 @@ def unfavourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/pin"
-  def pin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
+  def pin(%{assigns: %{user: user}} = conn, %{id: ap_id_or_id}) do
     with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
       try_render(conn, "show.json", activity: activity, for: user, as: :activity)
     end
   end
 
   @doc "POST /api/v1/statuses/:id/unpin"
-  def unpin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
+  def unpin(%{assigns: %{user: user}} = conn, %{id: ap_id_or_id}) do
     with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
       try_render(conn, "show.json", activity: activity, for: user, as: :activity)
     end
   end
 
   @doc "POST /api/v1/statuses/:id/bookmark"
-  def bookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def bookmark(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id_with_object(id),
          %User{} = user <- User.get_cached_by_nickname(user.nickname),
          true <- Visibility.visible_for_user?(activity, user),
@@ -254,7 +266,7 @@ def bookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/unbookmark"
-  def unbookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def unbookmark(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id_with_object(id),
          %User{} = user <- User.get_cached_by_nickname(user.nickname),
          true <- Visibility.visible_for_user?(activity, user),
@@ -264,7 +276,7 @@ def unbookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/mute"
-  def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def mute_conversation(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id(id),
          {:ok, activity} <- CommonAPI.add_mute(user, activity) do
       try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@@ -272,7 +284,7 @@ def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "POST /api/v1/statuses/:id/unmute"
-  def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def unmute_conversation(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id(id),
          {:ok, activity} <- CommonAPI.remove_mute(user, activity) do
       try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@@ -281,7 +293,7 @@ def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 
   @doc "GET /api/v1/statuses/:id/card"
   @deprecated "https://github.com/tootsuite/mastodon/pull/11213"
-  def card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
+  def card(%{assigns: %{user: user}} = conn, %{id: status_id}) do
     with %Activity{} = activity <- Activity.get_by_id(status_id),
          true <- Visibility.visible_for_user?(activity, user) do
       data = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
@@ -292,7 +304,7 @@ def card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
   end
 
   @doc "GET /api/v1/statuses/:id/favourited_by"
-  def favourited_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def favourited_by(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id_with_object(id),
          {:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
          %Object{data: %{"likes" => likes}} <- Object.normalize(activity) do
@@ -312,7 +324,7 @@ def favourited_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "GET /api/v1/statuses/:id/reblogged_by"
-  def reblogged_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def reblogged_by(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id_with_object(id),
          {:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
          %Object{data: %{"announcements" => announces, "id" => ap_id}} <-
@@ -344,7 +356,7 @@ def reblogged_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
   end
 
   @doc "GET /api/v1/statuses/:id/context"
-  def context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+  def context(%{assigns: %{user: user}} = conn, %{id: id}) do
     with %Activity{} = activity <- Activity.get_by_id(id) do
       activities =
         ActivityPub.fetch_activities_for_context(activity.data["context"], %{
@@ -359,11 +371,12 @@ def context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
 
   @doc "GET /api/v1/favourites"
   def favourites(%{assigns: %{user: %User{} = user}} = conn, params) do
-    activities =
-      ActivityPub.fetch_favourites(
-        user,
-        Map.take(params, Pleroma.Pagination.page_keys())
-      )
+    params =
+      params
+      |> Map.new(fn {key, value} -> {to_string(key), value} end)
+      |> Map.take(Pleroma.Pagination.page_keys())
+
+    activities = ActivityPub.fetch_favourites(user, params)
 
     conn
     |> add_link_headers(activities)
diff --git a/lib/pleroma/web/mastodon_api/controllers/suggestion_controller.ex b/lib/pleroma/web/mastodon_api/controllers/suggestion_controller.ex
index c93a43969..f91df9ab7 100644
--- a/lib/pleroma/web/mastodon_api/controllers/suggestion_controller.ex
+++ b/lib/pleroma/web/mastodon_api/controllers/suggestion_controller.ex
@@ -5,11 +5,26 @@
 defmodule Pleroma.Web.MastodonAPI.SuggestionController do
   use Pleroma.Web, :controller
 
-  alias Pleroma.Plugs.OAuthScopesPlug
-
   require Logger
 
-  plug(OAuthScopesPlug, %{scopes: ["read"]} when action == :index)
+  plug(Pleroma.Web.ApiSpec.CastAndValidate)
+  plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["read"]} when action == :index)
+
+  def open_api_operation(action) do
+    operation = String.to_existing_atom("#{action}_operation")
+    apply(__MODULE__, operation, [])
+  end
+
+  def index_operation do
+    %OpenApiSpex.Operation{
+      tags: ["Suggestions"],
+      summary: "Follow suggestions (Not implemented)",
+      operationId: "SuggestionController.index",
+      responses: %{
+        200 => Pleroma.Web.ApiSpec.Helpers.empty_array_response()
+      }
+    }
+  end
 
   @doc "GET /api/v1/suggestions"
   def index(conn, params),
diff --git a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
index 2d67e19da..bbd576ffd 100644
--- a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
+++ b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
@@ -6,7 +6,7 @@ defmodule Pleroma.Web.MastodonAPI.TimelineController do
   use Pleroma.Web, :controller
 
   import Pleroma.Web.ControllerHelper,
-    only: [add_link_headers: 2, add_link_headers: 3, truthy_param?: 1, skip_relationships?: 1]
+    only: [add_link_headers: 2, add_link_headers: 3, skip_relationships?: 1]
 
   alias Pleroma.Pagination
   alias Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug
@@ -15,6 +15,7 @@ defmodule Pleroma.Web.MastodonAPI.TimelineController do
   alias Pleroma.User
   alias Pleroma.Web.ActivityPub.ActivityPub
 
+  plug(Pleroma.Web.ApiSpec.CastAndValidate)
   plug(:skip_plug, EnsurePublicOrAuthenticatedPlug when action in [:public, :hashtag])
 
   # TODO: Replace with a macro when there is a Phoenix release with the following commit in it:
@@ -37,10 +38,13 @@ defmodule Pleroma.Web.MastodonAPI.TimelineController do
 
   plug(:put_view, Pleroma.Web.MastodonAPI.StatusView)
 
+  defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.TimelineOperation
+
   # GET /api/v1/timelines/home
   def home(%{assigns: %{user: user}} = conn, params) do
     params =
       params
+      |> Map.new(fn {key, value} -> {to_string(key), value} end)
       |> Map.put("type", ["Create", "Announce"])
       |> Map.put("blocking_user", user)
       |> Map.put("muting_user", user)
@@ -68,6 +72,7 @@ def home(%{assigns: %{user: user}} = conn, params) do
   def direct(%{assigns: %{user: user}} = conn, params) do
     params =
       params
+      |> Map.new(fn {key, value} -> {to_string(key), value} end)
       |> Map.put("type", "Create")
       |> Map.put("blocking_user", user)
       |> Map.put("user", user)
@@ -90,7 +95,9 @@ def direct(%{assigns: %{user: user}} = conn, params) do
 
   # GET /api/v1/timelines/public
   def public(%{assigns: %{user: user}} = conn, params) do
-    local_only = truthy_param?(params["local"])
+    params = Map.new(params, fn {key, value} -> {to_string(key), value} end)
+
+    local_only = params["local"]
 
     cfg_key =
       if local_only do
@@ -157,8 +164,8 @@ defp hashtag_fetching(params, user, local_only) do
 
   # GET /api/v1/timelines/tag/:tag
   def hashtag(%{assigns: %{user: user}} = conn, params) do
-    local_only = truthy_param?(params["local"])
-
+    params = Map.new(params, fn {key, value} -> {to_string(key), value} end)
+    local_only = params["local"]
     activities = hashtag_fetching(params, user, local_only)
 
     conn
@@ -172,10 +179,11 @@ def hashtag(%{assigns: %{user: user}} = conn, params) do
   end
 
   # GET /api/v1/timelines/list/:list_id
-  def list(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
+  def list(%{assigns: %{user: user}} = conn, %{list_id: id} = params) do
     with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
       params =
         params
+        |> Map.new(fn {key, value} -> {to_string(key), value} end)
         |> Map.put("type", "Create")
         |> Map.put("blocking_user", user)
         |> Map.put("user", user)
diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
index 2feda6807..19fbf0902 100644
--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
@@ -338,7 +338,11 @@ defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
   defp maybe_put_role(data, _, _), do: data
 
   defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
-    Kernel.put_in(data, [:pleroma, :notification_settings], user.notification_settings)
+    Kernel.put_in(
+      data,
+      [:pleroma, :notification_settings],
+      Map.from_struct(user.notification_settings)
+    )
   end
 
   defp maybe_put_notification_settings(data, _, _), do: data
diff --git a/lib/pleroma/web/mastodon_api/websocket_handler.ex b/lib/pleroma/web/mastodon_api/websocket_handler.ex
index 393d093e5..94e4595d8 100644
--- a/lib/pleroma/web/mastodon_api/websocket_handler.ex
+++ b/lib/pleroma/web/mastodon_api/websocket_handler.ex
@@ -19,26 +19,12 @@ defmodule Pleroma.Web.MastodonAPI.WebsocketHandler do
   # Hibernate every X messages
   @hibernate_every 100
 
-  @streams [
-    "public",
-    "public:local",
-    "public:media",
-    "public:local:media",
-    "user",
-    "user:notification",
-    "direct",
-    "list",
-    "hashtag"
-  ]
-  @anonymous_streams ["public", "public:local", "hashtag"]
-
   def init(%{qs: qs} = req, state) do
-    with params <- :cow_qs.parse_qs(qs),
+    with params <- Enum.into(:cow_qs.parse_qs(qs), %{}),
          sec_websocket <- :cowboy_req.header("sec-websocket-protocol", req, nil),
-         access_token <- List.keyfind(params, "access_token", 0),
-         {_, stream} <- List.keyfind(params, "stream", 0),
-         {:ok, user} <- allow_request(stream, [access_token, sec_websocket]),
-         topic when is_binary(topic) <- expand_topic(stream, params) do
+         access_token <- Map.get(params, "access_token"),
+         {:ok, user} <- authenticate_request(access_token, sec_websocket),
+         {:ok, topic} <- Streamer.get_topic(Map.get(params, "stream"), user, params) do
       req =
         if sec_websocket do
           :cowboy_req.set_resp_header("sec-websocket-protocol", sec_websocket, req)
@@ -49,14 +35,14 @@ def init(%{qs: qs} = req, state) do
       {:cowboy_websocket, req, %{user: user, topic: topic, count: 0, timer: nil},
        %{idle_timeout: @timeout}}
     else
-      {:error, code} ->
-        Logger.debug("#{__MODULE__} denied connection: #{inspect(code)} - #{inspect(req)}")
-        {:ok, req} = :cowboy_req.reply(code, req)
+      {:error, :bad_topic} ->
+        Logger.debug("#{__MODULE__} bad topic #{inspect(req)}")
+        {:ok, req} = :cowboy_req.reply(404, req)
         {:ok, req, state}
 
-      error ->
-        Logger.debug("#{__MODULE__} denied connection: #{inspect(error)} - #{inspect(req)}")
-        {:ok, req} = :cowboy_req.reply(400, req)
+      {:error, :unauthorized} ->
+        Logger.debug("#{__MODULE__} authentication error: #{inspect(req)}")
+        {:ok, req} = :cowboy_req.reply(401, req)
         {:ok, req, state}
     end
   end
@@ -124,50 +110,23 @@ def terminate(reason, _req, state) do
   end
 
   # Public streams without authentication.
-  defp allow_request(stream, [nil, nil]) when stream in @anonymous_streams do
+  defp authenticate_request(nil, nil) do
     {:ok, nil}
   end
 
   # Authenticated streams.
-  defp allow_request(stream, [access_token, sec_websocket]) when stream in @streams do
-    token =
-      with {"access_token", token} <- access_token do
-        token
-      else
-        _ -> sec_websocket
-      end
+  defp authenticate_request(access_token, sec_websocket) do
+    token = access_token || sec_websocket
 
     with true <- is_bitstring(token),
          %Token{user_id: user_id} <- Repo.get_by(Token, token: token),
          user = %User{} <- User.get_cached_by_id(user_id) do
       {:ok, user}
     else
-      _ -> {:error, 403}
+      _ -> {:error, :unauthorized}
     end
   end
 
-  # Not authenticated.
-  defp allow_request(stream, _) when stream in @streams, do: {:error, 403}
-
-  # No matching stream.
-  defp allow_request(_, _), do: {:error, 404}
-
-  defp expand_topic("hashtag", params) do
-    case List.keyfind(params, "tag", 0) do
-      {_, tag} -> "hashtag:#{tag}"
-      _ -> nil
-    end
-  end
-
-  defp expand_topic("list", params) do
-    case List.keyfind(params, "list", 0) do
-      {_, list} -> "list:#{list}"
-      _ -> nil
-    end
-  end
-
-  defp expand_topic(topic, _), do: topic
-
   defp timer do
     Process.send_after(self(), :tick, @tick)
   end
diff --git a/lib/pleroma/web/mongooseim/mongoose_im_controller.ex b/lib/pleroma/web/mongooseim/mongoose_im_controller.ex
index 1ed6ee521..0814b3bc3 100644
--- a/lib/pleroma/web/mongooseim/mongoose_im_controller.ex
+++ b/lib/pleroma/web/mongooseim/mongoose_im_controller.ex
@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.MongooseIM.MongooseIMController do
   use Pleroma.Web, :controller
 
-  alias Comeonin.Pbkdf2
   alias Pleroma.Plugs.RateLimiter
   alias Pleroma.Repo
   alias Pleroma.User
@@ -28,7 +27,7 @@ def user_exists(conn, %{"user" => username}) do
   def check_password(conn, %{"user" => username, "pass" => password}) do
     with %User{password_hash: password_hash, deactivated: false} <-
            Repo.get_by(User, nickname: username, local: true),
-         true <- Pbkdf2.checkpw(password, password_hash) do
+         true <- Pbkdf2.verify_pass(password, password_hash) do
       conn
       |> json(true)
     else
diff --git a/lib/pleroma/web/streamer/streamer.ex b/lib/pleroma/web/streamer/streamer.ex
index 5ad4aa936..49a400df7 100644
--- a/lib/pleroma/web/streamer/streamer.ex
+++ b/lib/pleroma/web/streamer/streamer.ex
@@ -21,12 +21,68 @@ defmodule Pleroma.Web.Streamer do
 
   def registry, do: @registry
 
-  def add_socket(topic, %User{} = user) do
-    if should_env_send?(), do: Registry.register(@registry, user_topic(topic, user), true)
+  @public_streams ["public", "public:local", "public:media", "public:local:media"]
+  @user_streams ["user", "user:notification", "direct"]
+
+  @doc "Expands and authorizes a stream, and registers the process for streaming."
+  @spec get_topic_and_add_socket(stream :: String.t(), User.t() | nil, Map.t() | nil) ::
+          {:ok, topic :: String.t()} | {:error, :bad_topic} | {:error, :unauthorized}
+  def get_topic_and_add_socket(stream, user, params \\ %{}) do
+    case get_topic(stream, user, params) do
+      {:ok, topic} -> add_socket(topic, user)
+      error -> error
+    end
   end
 
-  def add_socket(topic, _) do
-    if should_env_send?(), do: Registry.register(@registry, topic, false)
+  @doc "Expand and authorizes a stream"
+  @spec get_topic(stream :: String.t(), User.t() | nil, Map.t()) ::
+          {:ok, topic :: String.t()} | {:error, :bad_topic}
+  def get_topic(stream, user, params \\ %{})
+
+  # Allow all public steams.
+  def get_topic(stream, _, _) when stream in @public_streams do
+    {:ok, stream}
+  end
+
+  # Allow all hashtags streams.
+  def get_topic("hashtag", _, %{"tag" => tag}) do
+    {:ok, "hashtag:" <> tag}
+  end
+
+  # Expand user streams.
+  def get_topic(stream, %User{} = user, _) when stream in @user_streams do
+    {:ok, stream <> ":" <> to_string(user.id)}
+  end
+
+  def get_topic(stream, _, _) when stream in @user_streams do
+    {:error, :unauthorized}
+  end
+
+  # List streams.
+  def get_topic("list", %User{} = user, %{"list" => id}) do
+    if Pleroma.List.get(id, user) do
+      {:ok, "list:" <> to_string(id)}
+    else
+      {:error, :bad_topic}
+    end
+  end
+
+  def get_topic("list", _, _) do
+    {:error, :unauthorized}
+  end
+
+  def get_topic(_, _, _) do
+    {:error, :bad_topic}
+  end
+
+  @doc "Registers the process for streaming. Use `get_topic/3` to get the full authorized topic."
+  def add_socket(topic, user) do
+    if should_env_send?() do
+      auth? = if user, do: true
+      Registry.register(@registry, topic, auth?)
+    end
+
+    {:ok, topic}
   end
 
   def remove_socket(topic) do
@@ -231,13 +287,4 @@ def should_env_send?, do: false
     true ->
       def should_env_send?, do: true
   end
-
-  defp user_topic(topic, user)
-       when topic in ~w[user user:notification direct] do
-    "#{topic}:#{user.id}"
-  end
-
-  defp user_topic(topic, _) do
-    topic
-  end
 end
diff --git a/lib/pleroma/workers/scheduled_activity_worker.ex b/lib/pleroma/workers/scheduled_activity_worker.ex
index 8905f4ad0..97d1efbfb 100644
--- a/lib/pleroma/workers/scheduled_activity_worker.ex
+++ b/lib/pleroma/workers/scheduled_activity_worker.ex
@@ -30,6 +30,8 @@ def perform(%{"activity_id" => activity_id}, _job) do
   end
 
   defp post_activity(%ScheduledActivity{user_id: user_id, params: params} = scheduled_activity) do
+    params = Map.new(params, fn {key, value} -> {String.to_existing_atom(key), value} end)
+
     with {:delete, {:ok, _}} <- {:delete, ScheduledActivity.delete(scheduled_activity)},
          {:user, %User{} = user} <- {:user, User.get_cached_by_id(user_id)},
          {:post, {:ok, _}} <- {:post, CommonAPI.post(user, params)} do
diff --git a/mix.exs b/mix.exs
index 97b561790..0186d291f 100644
--- a/mix.exs
+++ b/mix.exs
@@ -36,7 +36,7 @@ def project do
       releases: [
         pleroma: [
           include_executables_for: [:unix],
-          applications: [ex_syslogger: :load, syslog: :load],
+          applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
           steps: [:assemble, &put_otp_version/1, &copy_files/1, &copy_nginx_config/1]
         ]
       ]
@@ -78,8 +78,7 @@ def application do
         :comeonin,
         :quack,
         :fast_sanitize,
-        :ssl,
-        :eldap
+        :ssl
       ],
       included_applications: [:ex_syslogger]
     ]
@@ -127,8 +126,7 @@ defp deps do
       {:postgrex, ">= 0.13.5"},
       {:oban, "~> 1.2"},
       {:gettext, "~> 0.15"},
-      {:comeonin, "~> 4.1.1"},
-      {:pbkdf2_elixir, "~> 0.12.3"},
+      {:pbkdf2_elixir, "~> 1.0"},
       {:trailing_format_plug, "~> 0.0.7"},
       {:fast_sanitize, "~> 0.1"},
       {:html_entities, "~> 0.5", override: true},
@@ -200,7 +198,7 @@ defp deps do
       {:restarter, path: "./restarter"},
       {:open_api_spex,
        git: "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git",
-       ref: "b862ebd78de0df95875cf46feb6e9607130dc2a8"}
+       ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"}
     ] ++ oauth_deps()
   end
 
diff --git a/mix.lock b/mix.lock
index c400202b7..62fe35146 100644
--- a/mix.lock
+++ b/mix.lock
@@ -13,7 +13,7 @@
   "castore": {:hex, :castore, "0.1.5", "591c763a637af2cc468a72f006878584bc6c306f8d111ef8ba1d4c10e0684010", [:mix], [], "hexpm", "6db356b2bc6cc22561e051ff545c20ad064af57647e436650aa24d7d06cd941a"},
   "certifi": {:hex, :certifi, "2.5.1", "867ce347f7c7d78563450a18a6a28a8090331e77fa02380b4a21962a65d36ee5", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm", "805abd97539caf89ec6d4732c91e62ba9da0cda51ac462380bbd28ee697a8c42"},
   "combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
-  "comeonin": {:hex, :comeonin, "4.1.2", "3eb5620fd8e35508991664b4c2b04dd41e52f1620b36957be837c1d7784b7592", [:mix], [{:argon2_elixir, "~> 1.2", [hex: :argon2_elixir, repo: "hexpm", optional: true]}, {:bcrypt_elixir, "~> 0.12.1 or ~> 1.0", [hex: :bcrypt_elixir, repo: "hexpm", optional: true]}, {:pbkdf2_elixir, "~> 0.12", [hex: :pbkdf2_elixir, repo: "hexpm", optional: true]}], "hexpm", "d8700a0ca4dbb616c22c9b3f6dd539d88deaafec3efe66869d6370c9a559b3e9"},
+  "comeonin": {:hex, :comeonin, "5.3.1", "7fe612b739c78c9c1a75186ef2d322ce4d25032d119823269d0aa1e2f1e20025", [:mix], [], "hexpm", "d6222483060c17f0977fad1b7401ef0c5863c985a64352755f366aee3799c245"},
   "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm", "4a0850c9be22a43af9920a71ab17c051f5f7d45c209e40269a1938832510e4d9"},
   "cors_plug": {:hex, :cors_plug, "1.5.2", "72df63c87e4f94112f458ce9d25800900cc88608c1078f0e4faddf20933eda6e", [:mix], [{:plug, "~> 1.3 or ~> 1.4 or ~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "9af027d20dc12dd0c4345a6b87247e0c62965871feea0bfecf9764648b02cc69"},
   "cowboy": {:hex, :cowboy, "2.7.0", "91ed100138a764355f43316b1d23d7ff6bdb0de4ea618cb5d8677c93a7a2f115", [:rebar3], [{:cowlib, "~> 2.8.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "04fd8c6a39edc6aaa9c26123009200fc61f92a3a94f3178c527b70b767c6e605"},
@@ -74,9 +74,9 @@
   "nimble_parsec": {:hex, :nimble_parsec, "0.5.3", "def21c10a9ed70ce22754fdeea0810dafd53c2db3219a0cd54cf5526377af1c6", [:mix], [], "hexpm", "589b5af56f4afca65217a1f3eb3fee7e79b09c40c742fddc1c312b3ac0b3399f"},
   "nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
   "oban": {:hex, :oban, "1.2.0", "7cca94d341be43d220571e28f69131c4afc21095b25257397f50973d3fc59b07", [:mix], [{:ecto_sql, "~> 3.1", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.14", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ba5f8b3f7d76967b3e23cf8014f6a13e4ccb33431e4808f036709a7f822362ee"},
-  "open_api_spex": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git", "b862ebd78de0df95875cf46feb6e9607130dc2a8", [ref: "b862ebd78de0df95875cf46feb6e9607130dc2a8"]},
+  "open_api_spex": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git", "f296ac0924ba3cf79c7a588c4c252889df4c2edd", [ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"]},
   "parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm", "17ef63abde837ad30680ea7f857dd9e7ced9476cdd7b0394432af4bfc241b960"},
-  "pbkdf2_elixir": {:hex, :pbkdf2_elixir, "0.12.4", "8dd29ed783f2e12195d7e0a4640effc0a7c37e6537da491f1db01839eee6d053", [:mix], [], "hexpm", "595d09db74cb093b1903381c9de423276a931a2480a46a1a5dc7f932a2a6375b"},
+  "pbkdf2_elixir": {:hex, :pbkdf2_elixir, "1.2.1", "9cbe354b58121075bd20eb83076900a3832324b7dd171a6895fab57b6bb2752c", [:mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}], "hexpm", "d3b40a4a4630f0b442f19eca891fcfeeee4c40871936fed2f68e1c4faa30481f"},
   "phoenix": {:hex, :phoenix, "1.4.13", "67271ad69b51f3719354604f4a3f968f83aa61c19199343656c9caee057ff3b8", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ab765a0feddb81fc62e2116c827b5f068df85159c162bee760745276ad7ddc1b"},
   "phoenix_ecto": {:hex, :phoenix_ecto, "4.1.0", "a044d0756d0464c5a541b4a0bf4bcaf89bffcaf92468862408290682c73ae50d", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "c5e666a341ff104d0399d8f0e4ff094559b2fde13a5985d4cb5023b2c2ac558b"},
   "phoenix_html": {:hex, :phoenix_html, "2.14.0", "d8c6bc28acc8e65f8ea0080ee05aa13d912c8758699283b8d3427b655aabe284", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "b0bb30eda478a06dbfbe96728061a93833db3861a49ccb516f839ecb08493fbb"},
diff --git a/test/activity_test.exs b/test/activity_test.exs
index 0c19f481b..507027e5a 100644
--- a/test/activity_test.exs
+++ b/test/activity_test.exs
@@ -125,8 +125,8 @@ test "when association is not loaded" do
         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
       }
 
-      {:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{"status" => "find me!"})
-      {:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{"status" => "更新情報"})
+      {:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "find me!"})
+      {:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "更新情報"})
       {:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
       {:ok, remote_activity} = ObanHelpers.perform(job)
 
@@ -225,8 +225,8 @@ test "get_by_id/1" do
   test "all_by_actor_and_id/2" do
     user = insert(:user)
 
-    {:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{"status" => "cofe"})
-    {:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{"status" => "cofefe"})
+    {:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
+    {:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofefe"})
 
     assert [] == Activity.all_by_actor_and_id(user, [])
 
diff --git a/test/bbs/handler_test.exs b/test/bbs/handler_test.exs
index 74982547b..eb716486e 100644
--- a/test/bbs/handler_test.exs
+++ b/test/bbs/handler_test.exs
@@ -21,8 +21,8 @@ test "getting the home timeline" do
 
     {:ok, user} = User.follow(user, followed)
 
-    {:ok, _first} = CommonAPI.post(user, %{"status" => "hey"})
-    {:ok, _second} = CommonAPI.post(followed, %{"status" => "hello"})
+    {:ok, _first} = CommonAPI.post(user, %{status: "hey"})
+    {:ok, _second} = CommonAPI.post(followed, %{status: "hello"})
 
     output =
       capture_io(fn ->
@@ -62,7 +62,7 @@ test "replying" do
     user = insert(:user)
     another_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(another_user, %{"status" => "this is a test post"})
+    {:ok, activity} = CommonAPI.post(another_user, %{status: "this is a test post"})
     activity_object = Object.normalize(activity)
 
     output =
diff --git a/test/bookmark_test.exs b/test/bookmark_test.exs
index 021f79322..2726fe7cd 100644
--- a/test/bookmark_test.exs
+++ b/test/bookmark_test.exs
@@ -11,7 +11,7 @@ defmodule Pleroma.BookmarkTest do
   describe "create/2" do
     test "with valid params" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "Some cool information"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "Some cool information"})
       {:ok, bookmark} = Bookmark.create(user.id, activity.id)
       assert bookmark.user_id == user.id
       assert bookmark.activity_id == activity.id
@@ -32,7 +32,7 @@ test "with invalid params" do
     test "with valid params" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "Some cool information"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "Some cool information"})
       {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
 
       {:ok, _deleted_bookmark} = Bookmark.destroy(user.id, activity.id)
@@ -45,7 +45,7 @@ test "gets a bookmark" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
+          status:
             "Scientists Discover The Secret Behind Tenshi Eating A Corndog Being So Cute – Science Daily"
         })
 
diff --git a/test/conversation/participation_test.exs b/test/conversation/participation_test.exs
index 3536842e8..59a1b6492 100644
--- a/test/conversation/participation_test.exs
+++ b/test/conversation/participation_test.exs
@@ -16,7 +16,7 @@ test "getting a participation will also preload things" do
     other_user = insert(:user)
 
     {:ok, _activity} =
-      CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hey @#{other_user.nickname}.", visibility: "direct"})
 
     [participation] = Participation.for_user(user)
 
@@ -30,7 +30,7 @@ test "for a new conversation or a reply, it doesn't mark the author's participat
     other_user = insert(:user)
 
     {:ok, _} =
-      CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hey @#{other_user.nickname}.", visibility: "direct"})
 
     user = User.get_cached_by_id(user.id)
     other_user = User.get_cached_by_id(other_user.id)
@@ -43,9 +43,9 @@ test "for a new conversation or a reply, it doesn't mark the author's participat
 
     {:ok, _} =
       CommonAPI.post(other_user, %{
-        "status" => "Hey @#{user.nickname}.",
-        "visibility" => "direct",
-        "in_reply_to_conversation_id" => participation.id
+        status: "Hey @#{user.nickname}.",
+        visibility: "direct",
+        in_reply_to_conversation_id: participation.id
       })
 
     user = User.get_cached_by_id(user.id)
@@ -64,7 +64,7 @@ test "for a new conversation, it sets the recipents of the participation" do
     third_user = insert(:user)
 
     {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hey @#{other_user.nickname}.", visibility: "direct"})
 
     user = User.get_cached_by_id(user.id)
     other_user = User.get_cached_by_id(other_user.id)
@@ -79,9 +79,9 @@ test "for a new conversation, it sets the recipents of the participation" do
 
     {:ok, _activity} =
       CommonAPI.post(user, %{
-        "in_reply_to_status_id" => activity.id,
-        "status" => "Hey @#{third_user.nickname}.",
-        "visibility" => "direct"
+        in_reply_to_status_id: activity.id,
+        status: "Hey @#{third_user.nickname}.",
+        visibility: "direct"
       })
 
     [participation] = Participation.for_user(user)
@@ -154,14 +154,14 @@ test "it marks all the user's participations as read" do
 
   test "gets all the participations for a user, ordered by updated at descending" do
     user = insert(:user)
-    {:ok, activity_one} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
-    {:ok, activity_two} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
+    {:ok, activity_one} = CommonAPI.post(user, %{status: "x", visibility: "direct"})
+    {:ok, activity_two} = CommonAPI.post(user, %{status: "x", visibility: "direct"})
 
     {:ok, activity_three} =
       CommonAPI.post(user, %{
-        "status" => "x",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => activity_one.id
+        status: "x",
+        visibility: "direct",
+        in_reply_to_status_id: activity_one.id
       })
 
     # Offset participations because the accuracy of updated_at is down to a second
@@ -201,7 +201,7 @@ test "gets all the participations for a user, ordered by updated at descending"
   test "Doesn't die when the conversation gets empty" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+    {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
     [participation] = Participation.for_user_with_last_activity_id(user)
 
     assert participation.last_activity_id == activity.id
@@ -215,7 +215,7 @@ test "it sets recipients, always keeping the owner of the participation even whe
     user = insert(:user)
     other_user = insert(:user)
 
-    {:ok, _activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+    {:ok, _activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
     [participation] = Participation.for_user_with_last_activity_id(user)
 
     participation = Repo.preload(participation, :recipients)
@@ -239,26 +239,26 @@ test "when the user blocks a recipient, the existing conversations with them are
 
       {:ok, _direct1} =
         CommonAPI.post(third_user, %{
-          "status" => "Hi @#{blocker.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}",
+          visibility: "direct"
         })
 
       {:ok, _direct2} =
         CommonAPI.post(third_user, %{
-          "status" => "Hi @#{blocker.nickname}, @#{blocked.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}, @#{blocked.nickname}",
+          visibility: "direct"
         })
 
       {:ok, _direct3} =
         CommonAPI.post(blocked, %{
-          "status" => "Hi @#{blocker.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}",
+          visibility: "direct"
         })
 
       {:ok, _direct4} =
         CommonAPI.post(blocked, %{
-          "status" => "Hi @#{blocker.nickname}, @#{third_user.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}, @#{third_user.nickname}",
+          visibility: "direct"
         })
 
       assert [%{read: false}, %{read: false}, %{read: false}, %{read: false}] =
@@ -293,8 +293,8 @@ test "the new conversation with the blocked user is not marked as unread " do
       # When the blocked user is the author
       {:ok, _direct1} =
         CommonAPI.post(blocked, %{
-          "status" => "Hi @#{blocker.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}",
+          visibility: "direct"
         })
 
       assert [%{read: true}] = Participation.for_user(blocker)
@@ -303,8 +303,8 @@ test "the new conversation with the blocked user is not marked as unread " do
       # When the blocked user is a recipient
       {:ok, _direct2} =
         CommonAPI.post(third_user, %{
-          "status" => "Hi @#{blocker.nickname}, @#{blocked.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}, @#{blocked.nickname}",
+          visibility: "direct"
         })
 
       assert [%{read: true}, %{read: true}] = Participation.for_user(blocker)
@@ -321,8 +321,8 @@ test "the conversation with the blocked user is not marked as unread on a reply"
 
       {:ok, _direct1} =
         CommonAPI.post(blocker, %{
-          "status" => "Hi @#{third_user.nickname}, @#{blocked.nickname}",
-          "visibility" => "direct"
+          status: "Hi @#{third_user.nickname}, @#{blocked.nickname}",
+          visibility: "direct"
         })
 
       {:ok, _user_relationship} = User.block(blocker, blocked)
@@ -334,9 +334,9 @@ test "the conversation with the blocked user is not marked as unread on a reply"
       # When it's a reply from the blocked user
       {:ok, _direct2} =
         CommonAPI.post(blocked, %{
-          "status" => "reply",
-          "visibility" => "direct",
-          "in_reply_to_conversation_id" => blocked_participation.id
+          status: "reply",
+          visibility: "direct",
+          in_reply_to_conversation_id: blocked_participation.id
         })
 
       assert [%{read: true}] = Participation.for_user(blocker)
@@ -347,9 +347,9 @@ test "the conversation with the blocked user is not marked as unread on a reply"
       # When it's a reply from the third user
       {:ok, _direct3} =
         CommonAPI.post(third_user, %{
-          "status" => "reply",
-          "visibility" => "direct",
-          "in_reply_to_conversation_id" => third_user_participation.id
+          status: "reply",
+          visibility: "direct",
+          in_reply_to_conversation_id: third_user_participation.id
         })
 
       assert [%{read: true}] = Participation.for_user(blocker)
diff --git a/test/conversation_test.exs b/test/conversation_test.exs
index 056a0e920..359aa6840 100644
--- a/test/conversation_test.exs
+++ b/test/conversation_test.exs
@@ -18,7 +18,7 @@ test "it goes through old direct conversations" do
     other_user = insert(:user)
 
     {:ok, _activity} =
-      CommonAPI.post(user, %{"visibility" => "direct", "status" => "hey @#{other_user.nickname}"})
+      CommonAPI.post(user, %{visibility: "direct", status: "hey @#{other_user.nickname}"})
 
     Pleroma.Tests.ObanHelpers.perform_all()
 
@@ -46,7 +46,7 @@ test "it creates a conversation for given ap_id" do
 
   test "public posts don't create conversations" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Hey"})
 
     object = Pleroma.Object.normalize(activity)
     context = object.data["context"]
@@ -62,7 +62,7 @@ test "it creates or updates a conversation and participations for a given DM" do
     tridi = insert(:user)
 
     {:ok, activity} =
-      CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
+      CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})
 
     object = Pleroma.Object.normalize(activity)
     context = object.data["context"]
@@ -81,9 +81,9 @@ test "it creates or updates a conversation and participations for a given DM" do
 
     {:ok, activity} =
       CommonAPI.post(jafnhar, %{
-        "status" => "Hey @#{har.nickname}",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => activity.id
+        status: "Hey @#{har.nickname}",
+        visibility: "direct",
+        in_reply_to_status_id: activity.id
       })
 
     object = Pleroma.Object.normalize(activity)
@@ -105,9 +105,9 @@ test "it creates or updates a conversation and participations for a given DM" do
 
     {:ok, activity} =
       CommonAPI.post(tridi, %{
-        "status" => "Hey @#{har.nickname}",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => activity.id
+        status: "Hey @#{har.nickname}",
+        visibility: "direct",
+        in_reply_to_status_id: activity.id
       })
 
     object = Pleroma.Object.normalize(activity)
@@ -149,14 +149,14 @@ test "create_or_bump_for returns the conversation with participations" do
     jafnhar = insert(:user, local: false)
 
     {:ok, activity} =
-      CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
+      CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})
 
     {:ok, conversation} = Conversation.create_or_bump_for(activity)
 
     assert length(conversation.participations) == 2
 
     {:ok, activity} =
-      CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "public"})
+      CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "public"})
 
     assert {:error, _} = Conversation.create_or_bump_for(activity)
   end
diff --git a/test/html_test.exs b/test/html_test.exs
index a006fd492..0a4b4ebbc 100644
--- a/test/html_test.exs
+++ b/test/html_test.exs
@@ -171,7 +171,7 @@ test "extracts the url" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
+          status:
             "I think I just found the best github repo https://github.com/komeiji-satori/Dress"
         })
 
@@ -186,7 +186,7 @@ test "skips mentions" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
+          status:
             "@#{other_user.nickname} install misskey! https://github.com/syuilo/misskey/blob/develop/docs/setup.en.md"
         })
 
@@ -203,8 +203,7 @@ test "skips hashtags" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
-            "#cofe https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
+          status: "#cofe https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
         })
 
       object = Object.normalize(activity)
@@ -218,9 +217,9 @@ test "skips microformats hashtags" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
+          status:
             "<a href=\"https://pleroma.gov/tags/cofe\" rel=\"tag\">#cofe</a> https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140",
-          "content_type" => "text/html"
+          content_type: "text/html"
         })
 
       object = Object.normalize(activity)
@@ -232,8 +231,7 @@ test "skips microformats hashtags" do
     test "does not crash when there is an HTML entity in a link" do
       user = insert(:user)
 
-      {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "\"http://cofe.com/?boomer=ok&foo=bar\""})
+      {:ok, activity} = CommonAPI.post(user, %{status: "\"http://cofe.com/?boomer=ok&foo=bar\""})
 
       object = Object.normalize(activity)
 
diff --git a/test/integration/mastodon_websocket_test.exs b/test/integration/mastodon_websocket_test.exs
index 109c7b4cb..ea17e9feb 100644
--- a/test/integration/mastodon_websocket_test.exs
+++ b/test/integration/mastodon_websocket_test.exs
@@ -32,7 +32,7 @@ def start_socket(qs \\ nil, headers \\ []) do
 
   test "refuses invalid requests" do
     capture_log(fn ->
-      assert {:error, {400, _}} = start_socket()
+      assert {:error, {404, _}} = start_socket()
       assert {:error, {404, _}} = start_socket("?stream=ncjdk")
       Process.sleep(30)
     end)
@@ -40,8 +40,8 @@ test "refuses invalid requests" do
 
   test "requires authentication and a valid token for protected streams" do
     capture_log(fn ->
-      assert {:error, {403, _}} = start_socket("?stream=user&access_token=aaaaaaaaaaaa")
-      assert {:error, {403, _}} = start_socket("?stream=user")
+      assert {:error, {401, _}} = start_socket("?stream=user&access_token=aaaaaaaaaaaa")
+      assert {:error, {401, _}} = start_socket("?stream=user")
       Process.sleep(30)
     end)
   end
@@ -55,7 +55,7 @@ test "allows public streams without authentication" do
   test "receives well formatted events" do
     user = insert(:user)
     {:ok, _} = start_socket("?stream=public")
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "nice echo chamber"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "nice echo chamber"})
 
     assert_receive {:text, raw_json}, 1_000
     assert {:ok, json} = Jason.decode(raw_json)
@@ -100,7 +100,7 @@ test "accepts the 'user' stream", %{token: token} = _state do
       assert {:ok, _} = start_socket("?stream=user&access_token=#{token.token}")
 
       assert capture_log(fn ->
-               assert {:error, {403, "Forbidden"}} = start_socket("?stream=user")
+               assert {:error, {401, _}} = start_socket("?stream=user")
                Process.sleep(30)
              end) =~ ":badarg"
     end
@@ -109,7 +109,7 @@ test "accepts the 'user:notification' stream", %{token: token} = _state do
       assert {:ok, _} = start_socket("?stream=user:notification&access_token=#{token.token}")
 
       assert capture_log(fn ->
-               assert {:error, {403, "Forbidden"}} = start_socket("?stream=user:notification")
+               assert {:error, {401, _}} = start_socket("?stream=user:notification")
                Process.sleep(30)
              end) =~ ":badarg"
     end
@@ -118,7 +118,7 @@ test "accepts valid token on Sec-WebSocket-Protocol header", %{token: token} do
       assert {:ok, _} = start_socket("?stream=user", [{"Sec-WebSocket-Protocol", token.token}])
 
       assert capture_log(fn ->
-               assert {:error, {403, "Forbidden"}} =
+               assert {:error, {401, _}} =
                         start_socket("?stream=user", [{"Sec-WebSocket-Protocol", "I am a friend"}])
 
                Process.sleep(30)
diff --git a/test/mfa_test.exs b/test/mfa_test.exs
index 94bc48c26..8875cefd9 100644
--- a/test/mfa_test.exs
+++ b/test/mfa_test.exs
@@ -6,7 +6,6 @@ defmodule Pleroma.MFATest do
   use Pleroma.DataCase
 
   import Pleroma.Factory
-  alias Comeonin.Pbkdf2
   alias Pleroma.MFA
 
   describe "mfa_settings" do
@@ -31,8 +30,8 @@ test "returns backup codes" do
       {:ok, [code1, code2]} = MFA.generate_backup_codes(user)
       updated_user = refresh_record(user)
       [hash1, hash2] = updated_user.multi_factor_authentication_settings.backup_codes
-      assert Pbkdf2.checkpw(code1, hash1)
-      assert Pbkdf2.checkpw(code2, hash2)
+      assert Pbkdf2.verify_pass(code1, hash1)
+      assert Pbkdf2.verify_pass(code2, hash2)
     end
   end
 
diff --git a/test/notification_test.exs b/test/notification_test.exs
index 24e5f0c73..111ff09f4 100644
--- a/test/notification_test.exs
+++ b/test/notification_test.exs
@@ -25,7 +25,7 @@ test "creates a notification for an emoji reaction" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
       {:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 
       {:ok, [notification]} = Notification.create_notifications(activity)
@@ -40,7 +40,7 @@ test "notifies someone when they are directly addressed" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
+          status: "hey @#{other_user.nickname} and @#{third_user.nickname}"
         })
 
       {:ok, [notification, other_notification]} = Notification.create_notifications(activity)
@@ -60,7 +60,7 @@ test "it creates a notification for subscribed users" do
 
       User.subscribe(subscriber, user)
 
-      {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
+      {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
       {:ok, [notification]} = Notification.create_notifications(status)
 
       assert notification.user_id == subscriber.id
@@ -73,12 +73,12 @@ test "does not create a notification for subscribed users if status is a reply"
 
       User.subscribe(subscriber, other_user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       {:ok, _reply_activity} =
         CommonAPI.post(other_user, %{
-          "status" => "test reply",
-          "in_reply_to_status_id" => activity.id
+          status: "test reply",
+          in_reply_to_status_id: activity.id
         })
 
       user_notifications = Notification.for_user(user)
@@ -98,7 +98,7 @@ test "does not create a notification for subscribed users if status is a reply"
       blocker = insert(:user)
       {:ok, _user_relationship} = User.block(blocker, user)
 
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "hey @#{blocker.nickname}!"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{blocker.nickname}!"})
 
       blocker_id = blocker.id
       assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification)
@@ -113,7 +113,7 @@ test "does not create a notification for subscribed users if status is a reply"
       muter = insert(:user)
       {:ok, _user_relationships} = User.mute(muter, user)
 
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "hey @#{muter.nickname}!"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{muter.nickname}!"})
 
       muter_id = muter.id
       assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification)
@@ -127,14 +127,14 @@ test "does not create a notification for subscribed users if status is a reply"
       user = insert(:user)
       thread_muter = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{thread_muter.nickname}!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{thread_muter.nickname}!"})
 
       {:ok, _} = CommonAPI.add_mute(thread_muter, activity)
 
       {:ok, _same_context_activity} =
         CommonAPI.post(user, %{
-          "status" => "hey-hey-hey @#{thread_muter.nickname}!",
-          "in_reply_to_status_id" => activity.id
+          status: "hey-hey-hey @#{thread_muter.nickname}!",
+          in_reply_to_status_id: activity.id
         })
 
       [pre_mute_notification, post_mute_notification] =
@@ -170,13 +170,13 @@ test "it creates a notification for user and send to the 'user' and the 'user:no
 
       task =
         Task.async(fn ->
-          Streamer.add_socket("user", user)
+          Streamer.get_topic_and_add_socket("user", user)
           assert_receive {:render_with_user, _, _, _}, 4_000
         end)
 
       task_user_notification =
         Task.async(fn ->
-          Streamer.add_socket("user:notification", user)
+          Streamer.get_topic_and_add_socket("user:notification", user)
           assert_receive {:render_with_user, _, _, _}, 4_000
         end)
 
@@ -202,7 +202,7 @@ test "it creates a notification for the user if the user mutes the activity auth
       muted = insert(:user)
       {:ok, _} = User.mute(muter, muted)
       muter = Repo.get(User, muter.id)
-      {:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})
+      {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})
 
       assert Notification.create_notification(activity, muter)
     end
@@ -213,7 +213,7 @@ test "notification created if user is muted without notifications" do
 
       {:ok, _user_relationships} = User.mute(muter, muted, false)
 
-      {:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})
+      {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})
 
       assert Notification.create_notification(activity, muter)
     end
@@ -221,13 +221,13 @@ test "notification created if user is muted without notifications" do
     test "it creates a notification for an activity from a muted thread" do
       muter = insert(:user)
       other_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(muter, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(muter, %{status: "hey"})
       CommonAPI.add_mute(muter, activity)
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
-          "status" => "Hi @#{muter.nickname}",
-          "in_reply_to_status_id" => activity.id
+          status: "Hi @#{muter.nickname}",
+          in_reply_to_status_id: activity.id
         })
 
       assert Notification.create_notification(activity, muter)
@@ -240,7 +240,7 @@ test "it disables notifications from followers" do
         insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false})
 
       User.follow(follower, followed)
-      {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
+      {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
       refute Notification.create_notification(activity, followed)
     end
 
@@ -252,7 +252,7 @@ test "it disables notifications from non-followers" do
           notification_settings: %Pleroma.User.NotificationSetting{non_followers: false}
         )
 
-      {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
+      {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
       refute Notification.create_notification(activity, followed)
     end
 
@@ -263,7 +263,7 @@ test "it disables notifications from people the user follows" do
       followed = insert(:user)
       User.follow(follower, followed)
       follower = Repo.get(User, follower.id)
-      {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
+      {:ok, activity} = CommonAPI.post(followed, %{status: "hey @#{follower.nickname}"})
       refute Notification.create_notification(activity, follower)
     end
 
@@ -272,7 +272,7 @@ test "it disables notifications from people the user does not follow" do
         insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})
 
       followed = insert(:user)
-      {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
+      {:ok, activity} = CommonAPI.post(followed, %{status: "hey @#{follower.nickname}"})
       refute Notification.create_notification(activity, follower)
     end
 
@@ -289,7 +289,7 @@ test "it doesn't create duplicate notifications for follow+subscribed users" do
 
       {:ok, _, _, _} = CommonAPI.follow(subscriber, user)
       User.subscribe(subscriber, user)
-      {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
+      {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
       {:ok, [_notif]} = Notification.create_notifications(status)
     end
 
@@ -299,7 +299,7 @@ test "it doesn't create subscription notifications if the recipient cannot see t
 
       User.subscribe(subscriber, user)
 
-      {:ok, status} = CommonAPI.post(user, %{"status" => "inwisible", "visibility" => "direct"})
+      {:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})
 
       assert {:ok, []} == Notification.create_notifications(status)
     end
@@ -370,7 +370,7 @@ test "it gets a notification that belongs to the user" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:ok, notification} = Notification.get(other_user, notification.id)
@@ -382,7 +382,7 @@ test "it returns error if the notification doesn't belong to the user" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:error, _notification} = Notification.get(user, notification.id)
@@ -394,7 +394,7 @@ test "it dismisses a notification that belongs to the user" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:ok, notification} = Notification.dismiss(other_user, notification.id)
@@ -406,7 +406,7 @@ test "it returns error if the notification doesn't belong to the user" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:error, _notification} = Notification.dismiss(user, notification.id)
@@ -421,14 +421,14 @@ test "it clears all notifications belonging to the user" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
+          status: "hey @#{other_user.nickname} and @#{third_user.nickname} !"
         })
 
       {:ok, _notifs} = Notification.create_notifications(activity)
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
+          status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
         })
 
       {:ok, _notifs} = Notification.create_notifications(activity)
@@ -446,12 +446,12 @@ test "it sets all notifications as read up to a specified notification ID" do
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"
         })
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
-          "status" => "hey again @#{other_user.nickname}!"
+          status: "hey again @#{other_user.nickname}!"
         })
 
       [n2, n1] = notifs = Notification.for_user(other_user)
@@ -461,7 +461,7 @@ test "it sets all notifications as read up to a specified notification ID" do
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
-          "status" => "hey yet again @#{other_user.nickname}!"
+          status: "hey yet again @#{other_user.nickname}!"
         })
 
       Notification.set_read_up_to(other_user, n2.id)
@@ -500,7 +500,7 @@ test "Returns recent notifications" do
       Enum.each(0..10, fn i ->
         {:ok, _activity} =
           CommonAPI.post(user1, %{
-            "status" => "hey ##{i} @#{user2.nickname}!"
+            status: "hey ##{i} @#{user2.nickname}!"
           })
       end)
 
@@ -536,7 +536,7 @@ test "it sends notifications to addressed users in new messages" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"
         })
 
       {enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)
@@ -605,7 +605,7 @@ test "it does not send notification to mentioned users in likes" do
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"
         })
 
       {:ok, activity_two} = CommonAPI.favorite(third_user, activity_one.id)
@@ -623,7 +623,7 @@ test "it only notifies the post's author in likes" do
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"
         })
 
       {:ok, like_data, _} = Builder.like(third_user, activity_one.object)
@@ -645,7 +645,7 @@ test "it does not send notification to mentioned users in announces" do
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{
-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"
         })
 
       {:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)
@@ -661,7 +661,7 @@ test "it returns blocking recipient in disabled recipients list" do
       other_user = insert(:user)
       {:ok, _user_relationship} = User.block(other_user, user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
 
       {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
 
@@ -674,7 +674,7 @@ test "it returns notification-muting recipient in disabled recipients list" do
       other_user = insert(:user)
       {:ok, _user_relationships} = User.mute(other_user, user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
 
       {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
 
@@ -686,14 +686,14 @@ test "it returns thread-muting recipient in disabled recipients list" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
 
       {:ok, _} = CommonAPI.add_mute(other_user, activity)
 
       {:ok, same_context_activity} =
         CommonAPI.post(user, %{
-          "status" => "hey-hey-hey @#{other_user.nickname}!",
-          "in_reply_to_status_id" => activity.id
+          status: "hey-hey-hey @#{other_user.nickname}!",
+          in_reply_to_status_id: activity.id
         })
 
       {enabled_receivers, disabled_receivers} =
@@ -710,7 +710,7 @@ test "it returns non-following domain-blocking recipient in disabled recipients
 
       {:ok, other_user} = User.block_domain(other_user, blocked_domain)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
 
       {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
 
@@ -726,7 +726,7 @@ test "it returns following domain-blocking recipient in enabled recipients list"
       {:ok, other_user} = User.block_domain(other_user, blocked_domain)
       {:ok, other_user} = User.follow(other_user, user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
 
       {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
 
@@ -740,7 +740,7 @@ test "liking an activity results in 1 notification, then 0 if the activity is de
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       assert Enum.empty?(Notification.for_user(user))
 
@@ -757,7 +757,7 @@ test "liking an activity results in 1 notification, then 0 if the activity is un
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       assert Enum.empty?(Notification.for_user(user))
 
@@ -774,7 +774,7 @@ test "repeating an activity results in 1 notification, then 0 if the activity is
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       assert Enum.empty?(Notification.for_user(user))
 
@@ -791,7 +791,7 @@ test "repeating an activity results in 1 notification, then 0 if the activity is
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       assert Enum.empty?(Notification.for_user(user))
 
@@ -808,7 +808,7 @@ test "liking an activity which is already deleted does not generate a notificati
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       assert Enum.empty?(Notification.for_user(user))
 
@@ -825,7 +825,7 @@ test "repeating an activity which is already deleted does not generate a notific
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
 
       assert Enum.empty?(Notification.for_user(user))
 
@@ -842,13 +842,13 @@ test "replying to a deleted post without tagging does not generate a notificatio
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
       {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
 
       {:ok, _reply_activity} =
         CommonAPI.post(other_user, %{
-          "status" => "test reply",
-          "in_reply_to_status_id" => activity.id
+          status: "test reply",
+          in_reply_to_status_id: activity.id
         })
 
       assert Enum.empty?(Notification.for_user(user))
@@ -859,7 +859,7 @@ test "notifications are deleted if a local user is deleted" do
       other_user = insert(:user)
 
       {:ok, _activity} =
-        CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}", "visibility" => "direct"})
+        CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})
 
       refute Enum.empty?(Notification.for_user(other_user))
 
@@ -970,7 +970,7 @@ test "it returns notifications for muted user without notifications" do
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted, false)
 
-      {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
 
       assert length(Notification.for_user(user)) == 1
     end
@@ -980,7 +980,7 @@ test "it doesn't return notifications for muted user with notifications" do
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted)
 
-      {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
 
       assert Notification.for_user(user) == []
     end
@@ -990,7 +990,7 @@ test "it doesn't return notifications for blocked user" do
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 
-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
 
       assert Notification.for_user(user) == []
     end
@@ -1000,7 +1000,7 @@ test "it doesn't return notifications for domain-blocked non-followed user" do
       blocked = insert(:user, ap_id: "http://some-domain.com")
       {:ok, user} = User.block_domain(user, "some-domain.com")
 
-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
 
       assert Notification.for_user(user) == []
     end
@@ -1012,7 +1012,7 @@ test "it returns notifications for domain-blocked but followed user" do
       {:ok, user} = User.block_domain(user, "some-domain.com")
       {:ok, _} = User.follow(user, blocked)
 
-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
 
       assert length(Notification.for_user(user)) == 1
     end
@@ -1021,7 +1021,7 @@ test "it doesn't return notifications for muted thread" do
       user = insert(:user)
       another_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"})
+      {:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})
 
       {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
       assert Notification.for_user(user) == []
@@ -1032,7 +1032,7 @@ test "it returns notifications from a muted user when with_muted is set" do
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted)
 
-      {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
 
       assert length(Notification.for_user(user, %{with_muted: true})) == 1
     end
@@ -1042,7 +1042,7 @@ test "it doesn't return notifications from a blocked user when with_muted is set
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 
-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
 
       assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
     end
@@ -1053,7 +1053,7 @@ test "when with_muted is set, " <>
       blocked = insert(:user, ap_id: "http://some-domain.com")
       {:ok, user} = User.block_domain(user, "some-domain.com")
 
-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
 
       assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
     end
@@ -1062,7 +1062,7 @@ test "it returns notifications from muted threads when with_muted is set" do
       user = insert(:user)
       another_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"})
+      {:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})
 
       {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
       assert length(Notification.for_user(user, %{with_muted: true})) == 1
diff --git a/test/plugs/authentication_plug_test.exs b/test/plugs/authentication_plug_test.exs
index 646bda9d3..31e20d726 100644
--- a/test/plugs/authentication_plug_test.exs
+++ b/test/plugs/authentication_plug_test.exs
@@ -16,7 +16,7 @@ defmodule Pleroma.Plugs.AuthenticationPlugTest do
     user = %User{
       id: 1,
       name: "dude",
-      password_hash: Comeonin.Pbkdf2.hashpwsalt("guy")
+      password_hash: Pbkdf2.hash_pwd_salt("guy")
     }
 
     conn =
diff --git a/test/stats_test.exs b/test/stats_test.exs
index c1aeb2c7f..4b76e2e78 100644
--- a/test/stats_test.exs
+++ b/test/stats_test.exs
@@ -22,26 +22,26 @@ test "on new status" do
       user = insert(:user)
       other_user = insert(:user)
 
-      CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
+      CommonAPI.post(user, %{visibility: "public", status: "hey"})
 
       Enum.each(0..1, fn _ ->
         CommonAPI.post(user, %{
-          "visibility" => "unlisted",
-          "status" => "hey"
+          visibility: "unlisted",
+          status: "hey"
         })
       end)
 
       Enum.each(0..2, fn _ ->
         CommonAPI.post(user, %{
-          "visibility" => "direct",
-          "status" => "hey @#{other_user.nickname}"
+          visibility: "direct",
+          status: "hey @#{other_user.nickname}"
         })
       end)
 
       Enum.each(0..3, fn _ ->
         CommonAPI.post(user, %{
-          "visibility" => "private",
-          "status" => "hey"
+          visibility: "private",
+          status: "hey"
         })
       end)
 
@@ -51,7 +51,7 @@ test "on new status" do
 
     test "on status delete" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
       assert %{public: 1} = Pleroma.Stats.get_status_visibility_count()
       CommonAPI.delete(activity.id, user)
       assert %{public: 0} = Pleroma.Stats.get_status_visibility_count()
@@ -59,16 +59,16 @@ test "on status delete" do
 
     test "on status visibility update" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
       assert %{public: 1, private: 0} = Pleroma.Stats.get_status_visibility_count()
-      {:ok, _} = CommonAPI.update_activity_scope(activity.id, %{"visibility" => "private"})
+      {:ok, _} = CommonAPI.update_activity_scope(activity.id, %{visibility: "private"})
       assert %{public: 0, private: 1} = Pleroma.Stats.get_status_visibility_count()
     end
 
     test "doesn't count unrelated activities" do
       user = insert(:user)
       other_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
       _ = CommonAPI.follow(user, other_user)
       CommonAPI.favorite(other_user, activity.id)
       CommonAPI.repeat(activity.id, other_user)
diff --git a/test/support/builders/user_builder.ex b/test/support/builders/user_builder.ex
index 0d0490714..0c687c029 100644
--- a/test/support/builders/user_builder.ex
+++ b/test/support/builders/user_builder.ex
@@ -7,7 +7,7 @@ def build(data \\ %{}) do
       email: "test@example.org",
       name: "Test Name",
       nickname: "testname",
-      password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
+      password_hash: Pbkdf2.hash_pwd_salt("test"),
       bio: "A tester.",
       ap_id: "some id",
       last_digest_emailed_at: NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
diff --git a/test/support/factory.ex b/test/support/factory.ex
index c8c45e2a7..d4284831c 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -29,7 +29,7 @@ def user_factory do
       name: sequence(:name, &"Test テスト User #{&1}"),
       email: sequence(:email, &"user#{&1}@example.com"),
       nickname: sequence(:nickname, &"nick#{&1}"),
-      password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
+      password_hash: Pbkdf2.hash_pwd_salt("test"),
       bio: sequence(:bio, &"Tester Number #{&1}"),
       last_digest_emailed_at: NaiveDateTime.utc_now(),
       last_refreshed_at: NaiveDateTime.utc_now(),
diff --git a/test/tasks/count_statuses_test.exs b/test/tasks/count_statuses_test.exs
index 73c2ea690..c5cd16960 100644
--- a/test/tasks/count_statuses_test.exs
+++ b/test/tasks/count_statuses_test.exs
@@ -13,11 +13,11 @@ defmodule Mix.Tasks.Pleroma.CountStatusesTest do
 
   test "counts statuses" do
     user = insert(:user)
-    {:ok, _} = CommonAPI.post(user, %{"status" => "test"})
-    {:ok, _} = CommonAPI.post(user, %{"status" => "test2"})
+    {:ok, _} = CommonAPI.post(user, %{status: "test"})
+    {:ok, _} = CommonAPI.post(user, %{status: "test2"})
 
     user2 = insert(:user)
-    {:ok, _} = CommonAPI.post(user2, %{"status" => "test3"})
+    {:ok, _} = CommonAPI.post(user2, %{status: "test3"})
 
     user = refresh_record(user)
     user2 = refresh_record(user2)
diff --git a/test/tasks/database_test.exs b/test/tasks/database_test.exs
index 7b05993d3..883828d77 100644
--- a/test/tasks/database_test.exs
+++ b/test/tasks/database_test.exs
@@ -26,7 +26,7 @@ defmodule Mix.Tasks.Pleroma.DatabaseTest do
   describe "running remove_embedded_objects" do
     test "it replaces objects with references" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test"})
       new_data = Map.put(activity.data, "object", activity.object.data)
 
       {:ok, activity} =
@@ -99,8 +99,8 @@ test "following and followers count are updated" do
     test "it turns OrderedCollection likes into empty arrays" do
       [user, user2] = insert_pair(:user)
 
-      {:ok, %{id: id, object: object}} = CommonAPI.post(user, %{"status" => "test"})
-      {:ok, %{object: object2}} = CommonAPI.post(user, %{"status" => "test test"})
+      {:ok, %{id: id, object: object}} = CommonAPI.post(user, %{status: "test"})
+      {:ok, %{object: object2}} = CommonAPI.post(user, %{status: "test test"})
 
       CommonAPI.favorite(user2, id)
 
diff --git a/test/tasks/digest_test.exs b/test/tasks/digest_test.exs
index 96d762685..eefbc8936 100644
--- a/test/tasks/digest_test.exs
+++ b/test/tasks/digest_test.exs
@@ -25,7 +25,7 @@ test "Sends digest to the given user" do
       Enum.each(0..10, fn i ->
         {:ok, _activity} =
           CommonAPI.post(user1, %{
-            "status" => "hey ##{i} @#{user2.nickname}!"
+            status: "hey ##{i} @#{user2.nickname}!"
           })
       end)
 
diff --git a/test/tasks/refresh_counter_cache_test.exs b/test/tasks/refresh_counter_cache_test.exs
index b63f44c08..851971a77 100644
--- a/test/tasks/refresh_counter_cache_test.exs
+++ b/test/tasks/refresh_counter_cache_test.exs
@@ -12,26 +12,26 @@ test "counts statuses" do
     user = insert(:user)
     other_user = insert(:user)
 
-    CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
+    CommonAPI.post(user, %{visibility: "public", status: "hey"})
 
     Enum.each(0..1, fn _ ->
       CommonAPI.post(user, %{
-        "visibility" => "unlisted",
-        "status" => "hey"
+        visibility: "unlisted",
+        status: "hey"
       })
     end)
 
     Enum.each(0..2, fn _ ->
       CommonAPI.post(user, %{
-        "visibility" => "direct",
-        "status" => "hey @#{other_user.nickname}"
+        visibility: "direct",
+        status: "hey @#{other_user.nickname}"
       })
     end)
 
     Enum.each(0..3, fn _ ->
       CommonAPI.post(user, %{
-        "visibility" => "private",
-        "status" => "hey"
+        visibility: "private",
+        status: "hey"
       })
     end)
 
diff --git a/test/tasks/user_test.exs b/test/tasks/user_test.exs
index b4f68d494..4aa873f0b 100644
--- a/test/tasks/user_test.exs
+++ b/test/tasks/user_test.exs
@@ -109,7 +109,7 @@ test "user is deleted" do
     test "a remote user's create activity is deleted when the object has been pruned" do
       user = insert(:user)
 
-      {:ok, post} = CommonAPI.post(user, %{"status" => "uguu"})
+      {:ok, post} = CommonAPI.post(user, %{status: "uguu"})
       object = Object.normalize(post)
       Object.prune(object)
 
diff --git a/test/user_test.exs b/test/user_test.exs
index a3c75aa9b..6b9df60a4 100644
--- a/test/user_test.exs
+++ b/test/user_test.exs
@@ -990,7 +990,7 @@ test "works for announces" do
       actor = insert(:user)
       user = insert(:user, local: true)
 
-      {:ok, activity} = CommonAPI.post(actor, %{"status" => "hello"})
+      {:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
       {:ok, announce, _} = CommonAPI.repeat(activity.id, user)
 
       recipients = User.get_recipients_from_activity(announce)
@@ -1007,7 +1007,7 @@ test "get recipients" do
 
       {:ok, activity} =
         CommonAPI.post(actor, %{
-          "status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
+          status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
         })
 
       assert Enum.map([actor, addressed], & &1.ap_id) --
@@ -1029,7 +1029,7 @@ test "has following" do
 
       {:ok, activity} =
         CommonAPI.post(actor, %{
-          "status" => "hey @#{addressed.nickname}"
+          status: "hey @#{addressed.nickname}"
         })
 
       assert Enum.map([actor, addressed], & &1.ap_id) --
@@ -1090,7 +1090,7 @@ test "hide a user's statuses from timelines and notifications" do
 
       {:ok, user2} = User.follow(user2, user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{user2.nickname}"})
 
       activity = Repo.preload(activity, :bookmark)
 
@@ -1126,7 +1126,7 @@ test "hide a user's statuses from timelines and notifications" do
     setup do: clear_config([:instance, :federating])
 
     test ".delete_user_activities deletes all create activities", %{user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "2hu"})
 
       User.delete_user_activities(user)
 
@@ -1411,7 +1411,7 @@ test "Only includes users who has no recent activity" do
 
         {:ok, _} =
           CommonAPI.post(user, %{
-            "status" => "hey @#{to.nickname}"
+            status: "hey @#{to.nickname}"
           })
       end)
 
@@ -1443,12 +1443,12 @@ test "Only includes users with no read notifications" do
       Enum.each(recipients, fn to ->
         {:ok, _} =
           CommonAPI.post(sender, %{
-            "status" => "hey @#{to.nickname}"
+            status: "hey @#{to.nickname}"
           })
 
         {:ok, _} =
           CommonAPI.post(sender, %{
-            "status" => "hey again @#{to.nickname}"
+            status: "hey again @#{to.nickname}"
           })
       end)
 
diff --git a/test/web/activity_pub/activity_pub_controller_test.exs b/test/web/activity_pub/activity_pub_controller_test.exs
index 776ddc8d4..c432c90e3 100644
--- a/test/web/activity_pub/activity_pub_controller_test.exs
+++ b/test/web/activity_pub/activity_pub_controller_test.exs
@@ -341,7 +341,7 @@ test "it caches a response", %{conn: conn} do
 
     test "cached purged after activity deletion", %{conn: conn} do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "cofe"})
 
       uuid = String.split(activity.data["id"], "/") |> List.last()
 
diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
index 0739cbfef..56fde97e7 100644
--- a/test/web/activity_pub/activity_pub_test.exs
+++ b/test/web/activity_pub/activity_pub_test.exs
@@ -32,7 +32,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
   describe "streaming out participations" do
     test "it streams them out" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+      {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
 
       {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
 
@@ -56,8 +56,8 @@ test "streams them out on activity creation" do
         stream: fn _, _ -> nil end do
         {:ok, activity} =
           CommonAPI.post(user_one, %{
-            "status" => "@#{user_two.nickname}",
-            "visibility" => "direct"
+            status: "@#{user_two.nickname}",
+            visibility: "direct"
           })
 
         conversation =
@@ -74,15 +74,13 @@ test "streams them out on activity creation" do
     test "it restricts by the appropriate visibility" do
       user = insert(:user)
 
-      {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
+      {:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 
-      {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+      {:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
 
-      {:ok, unlisted_activity} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
+      {:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
 
-      {:ok, private_activity} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
+      {:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 
       activities =
         ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
@@ -118,15 +116,13 @@ test "it restricts by the appropriate visibility" do
     test "it excludes by the appropriate visibility" do
       user = insert(:user)
 
-      {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
+      {:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 
-      {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+      {:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
 
-      {:ok, unlisted_activity} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
+      {:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
 
-      {:ok, private_activity} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
+      {:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 
       activities =
         ActivityPub.fetch_activities([], %{
@@ -193,9 +189,9 @@ test "it returns a user that is invisible" do
     test "it fetches the appropriate tag-restricted posts" do
       user = insert(:user)
 
-      {:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
-      {:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
-      {:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})
+      {:ok, status_one} = CommonAPI.post(user, %{status: ". #test"})
+      {:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
+      {:ok, status_three} = CommonAPI.post(user, %{status: ". #test #reject"})
 
       fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
 
@@ -432,26 +428,26 @@ test "increases user note count only for public activities" do
 
       {:ok, _} =
         CommonAPI.post(User.get_cached_by_id(user.id), %{
-          "status" => "1",
-          "visibility" => "public"
+          status: "1",
+          visibility: "public"
         })
 
       {:ok, _} =
         CommonAPI.post(User.get_cached_by_id(user.id), %{
-          "status" => "2",
-          "visibility" => "unlisted"
+          status: "2",
+          visibility: "unlisted"
         })
 
       {:ok, _} =
         CommonAPI.post(User.get_cached_by_id(user.id), %{
-          "status" => "2",
-          "visibility" => "private"
+          status: "2",
+          visibility: "private"
         })
 
       {:ok, _} =
         CommonAPI.post(User.get_cached_by_id(user.id), %{
-          "status" => "3",
-          "visibility" => "direct"
+          status: "3",
+          visibility: "direct"
         })
 
       user = User.get_cached_by_id(user.id)
@@ -462,27 +458,27 @@ test "increases replies count" do
       user = insert(:user)
       user2 = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
       ap_id = activity.data["id"]
-      reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
+      reply_data = %{status: "1", in_reply_to_status_id: activity.id}
 
       # public
-      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
+      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
       assert object.data["repliesCount"] == 1
 
       # unlisted
-      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
+      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
       assert object.data["repliesCount"] == 2
 
       # private
-      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
+      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
       assert object.data["repliesCount"] == 2
 
       # direct
-      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
+      {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
       assert object.data["repliesCount"] == 2
     end
@@ -569,13 +565,13 @@ test "doesn't return transitive interactions concerning blocked users" do
 
     {:ok, _user_relationship} = User.block(blocker, blockee)
 
-    {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
+    {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})
 
-    {:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
+    {:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})
 
-    {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
+    {:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
 
-    {:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
+    {:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})
 
     activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
 
@@ -592,9 +588,9 @@ test "doesn't return announce activities concerning blocked users" do
 
     {:ok, _user_relationship} = User.block(blocker, blockee)
 
-    {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
+    {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})
 
-    {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
+    {:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
 
     {:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)
 
@@ -774,10 +770,9 @@ test "excludes reblogs on request" do
     test "doesn't retrieve unlisted activities" do
       user = insert(:user)
 
-      {:ok, _unlisted_activity} =
-        CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
+      {:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})
 
-      {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
+      {:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})
 
       [activity] = ActivityPub.fetch_public_activities()
 
@@ -912,7 +907,7 @@ test "reverts annouce from object on error" do
   describe "announcing a private object" do
     test "adds an announce activity to the db if the audience is not widened" do
       user = insert(:user)
-      {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
+      {:ok, note_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
       object = Object.normalize(note_activity)
 
       {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
@@ -926,7 +921,7 @@ test "adds an announce activity to the db if the audience is not widened" do
 
     test "does not add an announce activity to the db if the audience is widened" do
       user = insert(:user)
-      {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
+      {:ok, note_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
       object = Object.normalize(note_activity)
 
       assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
@@ -935,7 +930,7 @@ test "does not add an announce activity to the db if the audience is widened" do
     test "does not add an announce activity to the db if the announcer is not the author" do
       user = insert(:user)
       announcer = insert(:user)
-      {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
+      {:ok, note_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
       object = Object.normalize(note_activity)
 
       assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
@@ -1061,14 +1056,38 @@ test "reverts block activity on error" do
     end
 
     test "creates a block activity" do
+      clear_config([:instance, :federating], true)
       blocker = insert(:user)
       blocked = insert(:user)
 
-      {:ok, activity} = ActivityPub.block(blocker, blocked)
+      with_mock Pleroma.Web.Federator,
+        publish: fn _ -> nil end do
+        {:ok, activity} = ActivityPub.block(blocker, blocked)
 
-      assert activity.data["type"] == "Block"
-      assert activity.data["actor"] == blocker.ap_id
-      assert activity.data["object"] == blocked.ap_id
+        assert activity.data["type"] == "Block"
+        assert activity.data["actor"] == blocker.ap_id
+        assert activity.data["object"] == blocked.ap_id
+
+        assert called(Pleroma.Web.Federator.publish(activity))
+      end
+    end
+
+    test "works with outgoing blocks disabled, but doesn't federate" do
+      clear_config([:instance, :federating], true)
+      clear_config([:activitypub, :outgoing_blocks], false)
+      blocker = insert(:user)
+      blocked = insert(:user)
+
+      with_mock Pleroma.Web.Federator,
+        publish: fn _ -> nil end do
+        {:ok, activity} = ActivityPub.block(blocker, blocked)
+
+        assert activity.data["type"] == "Block"
+        assert activity.data["actor"] == blocker.ap_id
+        assert activity.data["object"] == blocked.ap_id
+
+        refute called(Pleroma.Web.Federator.publish(:_))
+      end
     end
   end
 
@@ -1087,23 +1106,22 @@ test "it filters broken threads" do
       {:ok, user3} = User.follow(user3, user2)
       assert User.following?(user3, user2)
 
-      {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
+      {:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})
 
-      {:ok, private_activity_1} =
-        CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
+      {:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})
 
       {:ok, private_activity_2} =
         CommonAPI.post(user2, %{
-          "status" => "hi 3",
-          "visibility" => "private",
-          "in_reply_to_status_id" => private_activity_1.id
+          status: "hi 3",
+          visibility: "private",
+          in_reply_to_status_id: private_activity_1.id
         })
 
       {:ok, private_activity_3} =
         CommonAPI.post(user3, %{
-          "status" => "hi 4",
-          "visibility" => "private",
-          "in_reply_to_status_id" => private_activity_2.id
+          status: "hi 4",
+          visibility: "private",
+          in_reply_to_status_id: private_activity_2.id
         })
 
       activities =
@@ -1153,9 +1171,9 @@ test "returned pinned statuses" do
     Config.put([:instance, :max_pinned_statuses], 3)
     user = insert(:user)
 
-    {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
-    {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
-    {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
+    {:ok, activity_one} = CommonAPI.post(user, %{status: "HI!!!"})
+    {:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})
+    {:ok, activity_three} = CommonAPI.post(user, %{status: "HI!!!"})
 
     CommonAPI.pin(activity_one.id, user)
     user = refresh_record(user)
@@ -1176,7 +1194,7 @@ test "returned pinned statuses" do
       reporter = insert(:user)
       target_account = insert(:user)
       content = "foobar"
-      {:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
+      {:ok, activity} = CommonAPI.post(target_account, %{status: content})
       context = Utils.generate_context_id()
 
       reporter_ap_id = reporter.ap_id
@@ -1272,8 +1290,7 @@ test "fetch_activities/2 returns activities addressed to a list " do
     {:ok, list} = Pleroma.List.create("foo", user)
     {:ok, list} = Pleroma.List.follow(list, member)
 
-    {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
 
     activity = Repo.preload(activity, :bookmark)
     activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
@@ -1291,8 +1308,8 @@ test "fetches private posts for followed users" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "thought I looked cute might delete later :3",
-          "visibility" => "private"
+          status: "thought I looked cute might delete later :3",
+          visibility: "private"
         })
 
       [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
@@ -1301,12 +1318,12 @@ test "fetches private posts for followed users" do
 
     test "fetches only public posts for other users" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})
 
       {:ok, _private_activity} =
         CommonAPI.post(user, %{
-          "status" => "why is tenshi eating a corndog so cute?",
-          "visibility" => "private"
+          status: "why is tenshi eating a corndog so cute?",
+          visibility: "private"
         })
 
       [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
@@ -1434,11 +1451,11 @@ test "returns a favourite activities sorted by adds to favorite" do
       other_user = insert(:user)
       user1 = insert(:user)
       user2 = insert(:user)
-      {:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"})
-      {:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"})
-      {:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "})
-      {:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "})
-      {:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "})
+      {:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
+      {:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
+      {:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
+      {:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
+      {:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})
 
       {:ok, _} = CommonAPI.favorite(user, a4.id)
       {:ok, _} = CommonAPI.favorite(other_user, a3.id)
@@ -1518,10 +1535,9 @@ test "old user must be in the new user's `also_known_as` list" do
   test "doesn't retrieve replies activities with exclude_replies" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
 
-    {:ok, _reply} =
-      CommonAPI.post(user, %{"status" => "yeah", "in_reply_to_status_id" => activity.id})
+    {:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})
 
     [result] = ActivityPub.fetch_public_activities(%{"exclude_replies" => "true"})
 
@@ -1834,84 +1850,84 @@ defp public_messages(_) do
     {:ok, u2} = User.follow(u2, u3)
     {:ok, u3} = User.follow(u3, u2)
 
-    {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status"})
+    {:ok, a1} = CommonAPI.post(u1, %{status: "Status"})
 
     {:ok, r1_1} =
       CommonAPI.post(u2, %{
-        "status" => "@#{u1.nickname} reply from u2 to u1",
-        "in_reply_to_status_id" => a1.id
+        status: "@#{u1.nickname} reply from u2 to u1",
+        in_reply_to_status_id: a1.id
       })
 
     {:ok, r1_2} =
       CommonAPI.post(u3, %{
-        "status" => "@#{u1.nickname} reply from u3 to u1",
-        "in_reply_to_status_id" => a1.id
+        status: "@#{u1.nickname} reply from u3 to u1",
+        in_reply_to_status_id: a1.id
       })
 
     {:ok, r1_3} =
       CommonAPI.post(u4, %{
-        "status" => "@#{u1.nickname} reply from u4 to u1",
-        "in_reply_to_status_id" => a1.id
+        status: "@#{u1.nickname} reply from u4 to u1",
+        in_reply_to_status_id: a1.id
       })
 
-    {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status"})
+    {:ok, a2} = CommonAPI.post(u2, %{status: "Status"})
 
     {:ok, r2_1} =
       CommonAPI.post(u1, %{
-        "status" => "@#{u2.nickname} reply from u1 to u2",
-        "in_reply_to_status_id" => a2.id
+        status: "@#{u2.nickname} reply from u1 to u2",
+        in_reply_to_status_id: a2.id
       })
 
     {:ok, r2_2} =
       CommonAPI.post(u3, %{
-        "status" => "@#{u2.nickname} reply from u3 to u2",
-        "in_reply_to_status_id" => a2.id
+        status: "@#{u2.nickname} reply from u3 to u2",
+        in_reply_to_status_id: a2.id
       })
 
     {:ok, r2_3} =
       CommonAPI.post(u4, %{
-        "status" => "@#{u2.nickname} reply from u4 to u2",
-        "in_reply_to_status_id" => a2.id
+        status: "@#{u2.nickname} reply from u4 to u2",
+        in_reply_to_status_id: a2.id
       })
 
-    {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status"})
+    {:ok, a3} = CommonAPI.post(u3, %{status: "Status"})
 
     {:ok, r3_1} =
       CommonAPI.post(u1, %{
-        "status" => "@#{u3.nickname} reply from u1 to u3",
-        "in_reply_to_status_id" => a3.id
+        status: "@#{u3.nickname} reply from u1 to u3",
+        in_reply_to_status_id: a3.id
       })
 
     {:ok, r3_2} =
       CommonAPI.post(u2, %{
-        "status" => "@#{u3.nickname} reply from u2 to u3",
-        "in_reply_to_status_id" => a3.id
+        status: "@#{u3.nickname} reply from u2 to u3",
+        in_reply_to_status_id: a3.id
       })
 
     {:ok, r3_3} =
       CommonAPI.post(u4, %{
-        "status" => "@#{u3.nickname} reply from u4 to u3",
-        "in_reply_to_status_id" => a3.id
+        status: "@#{u3.nickname} reply from u4 to u3",
+        in_reply_to_status_id: a3.id
       })
 
-    {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status"})
+    {:ok, a4} = CommonAPI.post(u4, %{status: "Status"})
 
     {:ok, r4_1} =
       CommonAPI.post(u1, %{
-        "status" => "@#{u4.nickname} reply from u1 to u4",
-        "in_reply_to_status_id" => a4.id
+        status: "@#{u4.nickname} reply from u1 to u4",
+        in_reply_to_status_id: a4.id
       })
 
     {:ok, r4_2} =
       CommonAPI.post(u2, %{
-        "status" => "@#{u4.nickname} reply from u2 to u4",
-        "in_reply_to_status_id" => a4.id
+        status: "@#{u4.nickname} reply from u2 to u4",
+        in_reply_to_status_id: a4.id
       })
 
     {:ok, r4_3} =
       CommonAPI.post(u3, %{
-        "status" => "@#{u4.nickname} reply from u3 to u4",
-        "in_reply_to_status_id" => a4.id
+        status: "@#{u4.nickname} reply from u3 to u4",
+        in_reply_to_status_id: a4.id
       })
 
     {:ok,
@@ -1935,68 +1951,68 @@ defp private_messages(_) do
     {:ok, u2} = User.follow(u2, u3)
     {:ok, u3} = User.follow(u3, u2)
 
-    {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status", "visibility" => "private"})
+    {:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})
 
     {:ok, r1_1} =
       CommonAPI.post(u2, %{
-        "status" => "@#{u1.nickname} reply from u2 to u1",
-        "in_reply_to_status_id" => a1.id,
-        "visibility" => "private"
+        status: "@#{u1.nickname} reply from u2 to u1",
+        in_reply_to_status_id: a1.id,
+        visibility: "private"
       })
 
     {:ok, r1_2} =
       CommonAPI.post(u3, %{
-        "status" => "@#{u1.nickname} reply from u3 to u1",
-        "in_reply_to_status_id" => a1.id,
-        "visibility" => "private"
+        status: "@#{u1.nickname} reply from u3 to u1",
+        in_reply_to_status_id: a1.id,
+        visibility: "private"
       })
 
     {:ok, r1_3} =
       CommonAPI.post(u4, %{
-        "status" => "@#{u1.nickname} reply from u4 to u1",
-        "in_reply_to_status_id" => a1.id,
-        "visibility" => "private"
+        status: "@#{u1.nickname} reply from u4 to u1",
+        in_reply_to_status_id: a1.id,
+        visibility: "private"
       })
 
-    {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status", "visibility" => "private"})
+    {:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})
 
     {:ok, r2_1} =
       CommonAPI.post(u1, %{
-        "status" => "@#{u2.nickname} reply from u1 to u2",
-        "in_reply_to_status_id" => a2.id,
-        "visibility" => "private"
+        status: "@#{u2.nickname} reply from u1 to u2",
+        in_reply_to_status_id: a2.id,
+        visibility: "private"
       })
 
     {:ok, r2_2} =
       CommonAPI.post(u3, %{
-        "status" => "@#{u2.nickname} reply from u3 to u2",
-        "in_reply_to_status_id" => a2.id,
-        "visibility" => "private"
+        status: "@#{u2.nickname} reply from u3 to u2",
+        in_reply_to_status_id: a2.id,
+        visibility: "private"
       })
 
-    {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status", "visibility" => "private"})
+    {:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})
 
     {:ok, r3_1} =
       CommonAPI.post(u1, %{
-        "status" => "@#{u3.nickname} reply from u1 to u3",
-        "in_reply_to_status_id" => a3.id,
-        "visibility" => "private"
+        status: "@#{u3.nickname} reply from u1 to u3",
+        in_reply_to_status_id: a3.id,
+        visibility: "private"
       })
 
     {:ok, r3_2} =
       CommonAPI.post(u2, %{
-        "status" => "@#{u3.nickname} reply from u2 to u3",
-        "in_reply_to_status_id" => a3.id,
-        "visibility" => "private"
+        status: "@#{u3.nickname} reply from u2 to u3",
+        in_reply_to_status_id: a3.id,
+        visibility: "private"
       })
 
-    {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status", "visibility" => "private"})
+    {:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})
 
     {:ok, r4_1} =
       CommonAPI.post(u1, %{
-        "status" => "@#{u4.nickname} reply from u1 to u4",
-        "in_reply_to_status_id" => a4.id,
-        "visibility" => "private"
+        status: "@#{u4.nickname} reply from u1 to u4",
+        in_reply_to_status_id: a4.id,
+        visibility: "private"
       })
 
     {:ok,
diff --git a/test/web/activity_pub/object_validator_test.exs b/test/web/activity_pub/object_validator_test.exs
index 6164d176d..d9f5a8fac 100644
--- a/test/web/activity_pub/object_validator_test.exs
+++ b/test/web/activity_pub/object_validator_test.exs
@@ -159,7 +159,7 @@ test "does not validate if it doesn't concern local users" do
   describe "EmojiReacts" do
     setup do
       user = insert(:user)
-      {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
+      {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
 
       object = Pleroma.Object.get_by_ap_id(post_activity.data["object"])
 
@@ -199,7 +199,7 @@ test "it is not valid with a non-emoji content field", %{valid_emoji_react: vali
   describe "Undos" do
     setup do
       user = insert(:user)
-      {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
+      {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
       {:ok, like} = CommonAPI.favorite(user, post_activity.id)
       {:ok, valid_like_undo, []} = Builder.undo(user, like)
 
@@ -239,7 +239,7 @@ test "it does not validate if the object is missing", %{valid_like_undo: valid_l
   describe "deletes" do
     setup do
       user = insert(:user)
-      {:ok, post_activity} = CommonAPI.post(user, %{"status" => "cancel me daddy"})
+      {:ok, post_activity} = CommonAPI.post(user, %{status: "cancel me daddy"})
 
       {:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
       {:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)
@@ -331,7 +331,7 @@ test "it's valid if the actor of the object is a local superuser",
   describe "likes" do
     setup do
       user = insert(:user)
-      {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
+      {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
 
       valid_like = %{
         "to" => [user.ap_id],
diff --git a/test/web/activity_pub/side_effects_test.exs b/test/web/activity_pub/side_effects_test.exs
index 9e66c5752..148fa4442 100644
--- a/test/web/activity_pub/side_effects_test.exs
+++ b/test/web/activity_pub/side_effects_test.exs
@@ -26,8 +26,8 @@ defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, op} = CommonAPI.post(other_user, %{"status" => "big oof"})
-      {:ok, post} = CommonAPI.post(user, %{"status" => "hey", "in_reply_to_id" => op})
+      {:ok, op} = CommonAPI.post(other_user, %{status: "big oof"})
+      {:ok, post} = CommonAPI.post(user, %{status: "hey", in_reply_to_id: op})
       {:ok, favorite} = CommonAPI.favorite(user, post.id)
       object = Object.normalize(post)
       {:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
@@ -119,7 +119,7 @@ test "it handles user deletions", %{delete_user: delete, user: user} do
       poster = insert(:user)
       user = insert(:user)
 
-      {:ok, post} = CommonAPI.post(poster, %{"status" => "hey"})
+      {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
 
       {:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
       {:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)
@@ -145,7 +145,7 @@ test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
     setup do
       poster = insert(:user)
       user = insert(:user)
-      {:ok, post} = CommonAPI.post(poster, %{"status" => "hey"})
+      {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
       {:ok, like} = CommonAPI.favorite(user, post.id)
       {:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
       {:ok, announce, _} = CommonAPI.repeat(post.id, user)
@@ -245,7 +245,7 @@ test "deletes the original like", %{like_undo: like_undo, like: like} do
     setup do
       poster = insert(:user)
       user = insert(:user)
-      {:ok, post} = CommonAPI.post(poster, %{"status" => "hey"})
+      {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
 
       {:ok, like_data, _meta} = Builder.like(user, post.object)
       {:ok, like, _meta} = ActivityPub.persist(like_data, local: true)
diff --git a/test/web/activity_pub/transmogrifier/emoji_react_handling_test.exs b/test/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
index 6988e3e0a..0fb056b50 100644
--- a/test/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
+++ b/test/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
@@ -15,7 +15,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.EmojiReactHandlingTest do
   test "it works for incoming emoji reactions" do
     user = insert(:user)
     other_user = insert(:user, local: false)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
 
     data =
       File.read!("test/fixtures/emoji-reaction.json")
@@ -40,7 +40,7 @@ test "it works for incoming emoji reactions" do
   test "it reject invalid emoji reactions" do
     user = insert(:user)
     other_user = insert(:user, local: false)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
 
     data =
       File.read!("test/fixtures/emoji-reaction-too-long.json")
diff --git a/test/web/activity_pub/transmogrifier/like_handling_test.exs b/test/web/activity_pub/transmogrifier/like_handling_test.exs
index 54a5c1dbc..53fe1d550 100644
--- a/test/web/activity_pub/transmogrifier/like_handling_test.exs
+++ b/test/web/activity_pub/transmogrifier/like_handling_test.exs
@@ -14,7 +14,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.LikeHandlingTest do
   test "it works for incoming likes" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
 
     data =
       File.read!("test/fixtures/mastodon-like.json")
@@ -36,7 +36,7 @@ test "it works for incoming likes" do
   test "it works for incoming misskey likes, turning them into EmojiReacts" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
 
     data =
       File.read!("test/fixtures/misskey-like.json")
@@ -57,7 +57,7 @@ test "it works for incoming misskey likes, turning them into EmojiReacts" do
   test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReacts" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
 
     data =
       File.read!("test/fixtures/misskey-like.json")
diff --git a/test/web/activity_pub/transmogrifier/undo_handling_test.exs b/test/web/activity_pub/transmogrifier/undo_handling_test.exs
index eaf58adf7..01dd6c370 100644
--- a/test/web/activity_pub/transmogrifier/undo_handling_test.exs
+++ b/test/web/activity_pub/transmogrifier/undo_handling_test.exs
@@ -16,7 +16,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
   test "it works for incoming emoji reaction undos" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
     {:ok, reaction_activity} = CommonAPI.react_with_emoji(activity.id, user, "👌")
 
     data =
@@ -34,7 +34,7 @@ test "it works for incoming emoji reaction undos" do
 
   test "it returns an error for incoming unlikes wihout a like activity" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})
 
     data =
       File.read!("test/fixtures/mastodon-undo-like.json")
@@ -46,7 +46,7 @@ test "it returns an error for incoming unlikes wihout a like activity" do
 
   test "it works for incoming unlikes with an existing like activity" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})
 
     like_data =
       File.read!("test/fixtures/mastodon-like.json")
@@ -77,7 +77,7 @@ test "it works for incoming unlikes with an existing like activity" do
 
   test "it works for incoming unlikes with an existing like activity and a compact object" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})
 
     like_data =
       File.read!("test/fixtures/mastodon-like.json")
@@ -104,7 +104,7 @@ test "it works for incoming unlikes with an existing like activity and a compact
 
   test "it works for incoming unannounces with an existing notice" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 
     announce_data =
       File.read!("test/fixtures/mastodon-announce.json")
diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
index 2914c90ea..0a54e3bb9 100644
--- a/test/web/activity_pub/transmogrifier_test.exs
+++ b/test/web/activity_pub/transmogrifier_test.exs
@@ -212,8 +212,8 @@ test "it rewrites Note votes to Answers and increments vote counters on question
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "suya...",
-          "poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
+          status: "suya...",
+          poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
         })
 
       object = Object.normalize(activity)
@@ -260,6 +260,24 @@ test "it works for incoming notices with to/cc not being an array (kroeg)" do
                "<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
     end
 
+    test "it works for incoming honk announces" do
+      _user = insert(:user, ap_id: "https://honktest/u/test", local: false)
+      other_user = insert(:user)
+      {:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})
+
+      announce = %{
+        "@context" => "https://www.w3.org/ns/activitystreams",
+        "actor" => "https://honktest/u/test",
+        "id" => "https://honktest/u/test/bonk/1793M7B9MQ48847vdx",
+        "object" => post.data["object"],
+        "published" => "2019-06-25T19:33:58Z",
+        "to" => "https://www.w3.org/ns/activitystreams#Public",
+        "type" => "Announce"
+      }
+
+      {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(announce)
+    end
+
     test "it works for incoming announces with actor being inlined (kroeg)" do
       data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") |> Poison.decode!()
 
@@ -344,7 +362,7 @@ test "it works for incoming announces" do
 
     test "it works for incoming announces with an existing activity" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 
       data =
         File.read!("test/fixtures/mastodon-announce.json")
@@ -394,7 +412,7 @@ test "it rejects incoming announces with an inlined activity from another origin
 
     test "it does not clobber the addressing on announce activities" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 
       data =
         File.read!("test/fixtures/mastodon-announce.json")
@@ -480,7 +498,7 @@ test "it strips internal likes" do
 
     test "it strips internal reactions" do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
       {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "📢")
 
       %{object: object} = Activity.get_by_id_with_object(activity.id)
@@ -815,6 +833,12 @@ test "it works for incoming accepts which are referenced by IRI only" do
       follower = User.get_cached_by_id(follower.id)
 
       assert User.following?(follower, followed) == true
+
+      follower = User.get_by_id(follower.id)
+      assert follower.following_count == 1
+
+      followed = User.get_by_id(followed.id)
+      assert followed.follower_count == 1
     end
 
     test "it fails for incoming accepts which cannot be correlated" do
@@ -972,7 +996,7 @@ test "it accepts Flag activities" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
       object = Object.normalize(activity)
 
       note_obj = %{
@@ -1116,13 +1140,13 @@ test "does NOT schedule background fetching of `replies` beyond max thread depth
     setup do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "post1"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "post1"})
 
       {:ok, reply1} =
-        CommonAPI.post(user, %{"status" => "reply1", "in_reply_to_status_id" => activity.id})
+        CommonAPI.post(user, %{status: "reply1", in_reply_to_status_id: activity.id})
 
       {:ok, reply2} =
-        CommonAPI.post(user, %{"status" => "reply2", "in_reply_to_status_id" => activity.id})
+        CommonAPI.post(user, %{status: "reply2", in_reply_to_status_id: activity.id})
 
       replies_uris = Enum.map([reply1, reply2], fn a -> a.object.data["id"] end)
 
@@ -1162,7 +1186,7 @@ test "does NOT schedule background fetching of `replies` beyond max thread depth
     test "it inlines private announced objects" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey", "visibility" => "private"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey", visibility: "private"})
 
       {:ok, announce_activity, _} = CommonAPI.repeat(activity.id, user)
 
@@ -1177,7 +1201,7 @@ test "it turns mentions into tags" do
       other_user = insert(:user)
 
       {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})
+        CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})
 
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
       object = modified["object"]
@@ -1201,7 +1225,7 @@ test "it turns mentions into tags" do
     test "it adds the sensitive property" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "#nsfw hey"})
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
       assert modified["object"]["sensitive"]
@@ -1210,7 +1234,7 @@ test "it adds the sensitive property" do
     test "it adds the json-ld context and the conversation property" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
       assert modified["@context"] ==
@@ -1222,7 +1246,7 @@ test "it adds the json-ld context and the conversation property" do
     test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
@@ -1231,7 +1255,7 @@ test "it sets the 'attributedTo' property to the actor of the object if it doesn
     test "it strips internal hashtag data" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "#2hu"})
 
       expected_tag = %{
         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
@@ -1247,7 +1271,7 @@ test "it strips internal hashtag data" do
     test "it strips internal fields" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :firefox:"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "#2hu :firefox:"})
 
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
@@ -1279,14 +1303,13 @@ test "the directMessage flag is present" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "2hu :moominmamma:"})
 
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
       assert modified["directMessage"] == false
 
-      {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "@#{other_user.nickname} :moominmamma:"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "@#{other_user.nickname} :moominmamma:"})
 
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
@@ -1294,8 +1317,8 @@ test "the directMessage flag is present" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "@#{other_user.nickname} :moominmamma:",
-          "visibility" => "direct"
+          status: "@#{other_user.nickname} :moominmamma:",
+          visibility: "direct"
         })
 
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
@@ -1307,8 +1330,7 @@ test "it strips BCC field" do
       user = insert(:user)
       {:ok, list} = Pleroma.List.create("foo", user)
 
-      {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
 
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
@@ -1343,8 +1365,8 @@ test "it upgrades a user to activitypub" do
       user_two = insert(:user)
       Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
-      {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test"})
+      {:ok, unrelated_activity} = CommonAPI.post(user_two, %{status: "test"})
       assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
 
       user = User.get_cached_by_id(user.id)
@@ -1510,8 +1532,8 @@ test "Rewrites Answers to Notes" do
 
     {:ok, poll_activity} =
       CommonAPI.post(user, %{
-        "status" => "suya...",
-        "poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
+        status: "suya...",
+        poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
       })
 
     poll_object = Object.normalize(poll_activity)
@@ -1854,28 +1876,27 @@ test "returns unmodified object if activity doesn't have self-replies" do
     test "sets `replies` collection with a limited number of self-replies" do
       [user, another_user] = insert_list(2, :user)
 
-      {:ok, %{id: id1} = activity} = CommonAPI.post(user, %{"status" => "1"})
+      {:ok, %{id: id1} = activity} = CommonAPI.post(user, %{status: "1"})
 
       {:ok, %{id: id2} = self_reply1} =
-        CommonAPI.post(user, %{"status" => "self-reply 1", "in_reply_to_status_id" => id1})
+        CommonAPI.post(user, %{status: "self-reply 1", in_reply_to_status_id: id1})
 
       {:ok, self_reply2} =
-        CommonAPI.post(user, %{"status" => "self-reply 2", "in_reply_to_status_id" => id1})
+        CommonAPI.post(user, %{status: "self-reply 2", in_reply_to_status_id: id1})
 
       # Assuming to _not_ be present in `replies` due to :note_replies_output_limit is set to 2
-      {:ok, _} =
-        CommonAPI.post(user, %{"status" => "self-reply 3", "in_reply_to_status_id" => id1})
+      {:ok, _} = CommonAPI.post(user, %{status: "self-reply 3", in_reply_to_status_id: id1})
 
       {:ok, _} =
         CommonAPI.post(user, %{
-          "status" => "self-reply to self-reply",
-          "in_reply_to_status_id" => id2
+          status: "self-reply to self-reply",
+          in_reply_to_status_id: id2
         })
 
       {:ok, _} =
         CommonAPI.post(another_user, %{
-          "status" => "another user's reply",
-          "in_reply_to_status_id" => id1
+          status: "another user's reply",
+          in_reply_to_status_id: id1
         })
 
       object = Object.normalize(activity)
diff --git a/test/web/activity_pub/utils_test.exs b/test/web/activity_pub/utils_test.exs
index b8d811c73..9e0a0f1c4 100644
--- a/test/web/activity_pub/utils_test.exs
+++ b/test/web/activity_pub/utils_test.exs
@@ -120,7 +120,7 @@ test "addresses actor's follower address if the activity is public", %{
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
+          status:
             "hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
         })
 
@@ -139,8 +139,8 @@ test "does not adress actor's follower address if the activity is not public", %
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
-          "visibility" => "private"
+          status: "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
+          visibility: "private"
         })
 
       %{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
@@ -168,11 +168,11 @@ test "fetches existing votes" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "How do I pronounce LaTeX?",
-          "poll" => %{
-            "options" => ["laytekh", "lahtekh", "latex"],
-            "expires_in" => 20,
-            "multiple" => true
+          status: "How do I pronounce LaTeX?",
+          poll: %{
+            options: ["laytekh", "lahtekh", "latex"],
+            expires_in: 20,
+            multiple: true
           }
         })
 
@@ -187,10 +187,10 @@ test "fetches only Create activities" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "Are we living in a society?",
-          "poll" => %{
-            "options" => ["yes", "no"],
-            "expires_in" => 20
+          status: "Are we living in a society?",
+          poll: %{
+            options: ["yes", "no"],
+            expires_in: 20
           }
         })
 
@@ -469,7 +469,7 @@ test "returns empty map when params is invalid" do
     test "returns map with Flag object" do
       reporter = insert(:user)
       target_account = insert(:user)
-      {:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"})
+      {:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
       context = Utils.generate_context_id()
       content = "foobar"
 
diff --git a/test/web/activity_pub/views/object_view_test.exs b/test/web/activity_pub/views/object_view_test.exs
index 6c006206b..43f0617f0 100644
--- a/test/web/activity_pub/views/object_view_test.exs
+++ b/test/web/activity_pub/views/object_view_test.exs
@@ -44,7 +44,7 @@ test "renders `replies` collection for a note activity" do
       activity = insert(:note_activity, user: user)
 
       {:ok, self_reply1} =
-        CommonAPI.post(user, %{"status" => "self-reply 1", "in_reply_to_status_id" => activity.id})
+        CommonAPI.post(user, %{status: "self-reply 1", in_reply_to_status_id: activity.id})
 
       replies_uris = [self_reply1.object.data["id"]]
       result = ObjectView.render("object.json", %{object: refresh_record(activity)})
diff --git a/test/web/activity_pub/views/user_view_test.exs b/test/web/activity_pub/views/user_view_test.exs
index 8d00893a5..20b0f223c 100644
--- a/test/web/activity_pub/views/user_view_test.exs
+++ b/test/web/activity_pub/views/user_view_test.exs
@@ -164,7 +164,7 @@ test "activity collection page aginates correctly" do
 
     posts =
       for i <- 0..25 do
-        {:ok, activity} = CommonAPI.post(user, %{"status" => "post #{i}"})
+        {:ok, activity} = CommonAPI.post(user, %{status: "post #{i}"})
         activity
       end
 
diff --git a/test/web/activity_pub/visibilty_test.exs b/test/web/activity_pub/visibilty_test.exs
index 5b91630d4..8e9354c65 100644
--- a/test/web/activity_pub/visibilty_test.exs
+++ b/test/web/activity_pub/visibilty_test.exs
@@ -21,21 +21,21 @@ defmodule Pleroma.Web.ActivityPub.VisibilityTest do
     Pleroma.List.follow(list, unrelated)
 
     {:ok, public} =
-      CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"})
+      CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "public"})
 
     {:ok, private} =
-      CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "private"})
+      CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "private"})
 
     {:ok, direct} =
-      CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "direct"})
 
     {:ok, unlisted} =
-      CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"})
+      CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "unlisted"})
 
     {:ok, list} =
       CommonAPI.post(user, %{
-        "status" => "@#{mentioned.nickname}",
-        "visibility" => "list:#{list.id}"
+        status: "@#{mentioned.nickname}",
+        visibility: "list:#{list.id}"
       })
 
     %{
diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
index 4697af50e..ecf5465be 100644
--- a/test/web/admin_api/admin_api_controller_test.exs
+++ b/test/web/admin_api/admin_api_controller_test.exs
@@ -1747,7 +1747,7 @@ test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
     test "change visibility flag", %{conn: conn, id: id, admin: admin} do
       response =
         conn
-        |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
+        |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
         |> json_response(:ok)
 
       assert response["visibility"] == "public"
@@ -1759,21 +1759,21 @@ test "change visibility flag", %{conn: conn, id: id, admin: admin} do
 
       response =
         conn
-        |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
+        |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
         |> json_response(:ok)
 
       assert response["visibility"] == "private"
 
       response =
         conn
-        |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
+        |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
         |> json_response(:ok)
 
       assert response["visibility"] == "unlisted"
     end
 
     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
-      conn = put(conn, "/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
+      conn = put(conn, "/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})
 
       assert json_response(conn, :bad_request) == "Unsupported visibility"
     end
@@ -2977,13 +2977,12 @@ test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
       user = insert(:user)
       User.block(admin, blocked)
 
-      {:ok, _} =
-        CommonAPI.post(user, %{"status" => "@#{admin.nickname}", "visibility" => "direct"})
+      {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
 
-      {:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
-      {:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
-      {:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
-      {:ok, _} = CommonAPI.post(blocked, %{"status" => ".", "visibility" => "public"})
+      {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
+      {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
+      {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
+      {:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})
 
       response =
         conn
@@ -3011,11 +3010,10 @@ test "returns only local statuses with local_only on", %{conn: conn} do
     test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
       user = insert(:user)
 
-      {:ok, _} =
-        CommonAPI.post(user, %{"status" => "@#{admin.nickname}", "visibility" => "direct"})
+      {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
 
-      {:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
-      {:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
+      {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
+      {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
       conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
       assert json_response(conn, 200) |> length() == 3
     end
@@ -3049,11 +3047,9 @@ test "renders user's statuses with a limit", %{conn: conn, user: user} do
     end
 
     test "doesn't return private statuses by default", %{conn: conn, user: user} do
-      {:ok, _private_status} =
-        CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
+      {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
 
-      {:ok, _public_status} =
-        CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
+      {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
 
       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
 
@@ -3061,11 +3057,9 @@ test "doesn't return private statuses by default", %{conn: conn, user: user} do
     end
 
     test "returns private statuses with godmode on", %{conn: conn, user: user} do
-      {:ok, _private_status} =
-        CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
+      {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
 
-      {:ok, _public_status} =
-        CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
+      {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
 
       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
 
@@ -3074,7 +3068,7 @@ test "returns private statuses with godmode on", %{conn: conn, user: user} do
 
     test "excludes reblogs by default", %{conn: conn, user: user} do
       other_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "."})
+      {:ok, activity} = CommonAPI.post(user, %{status: "."})
       {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, other_user)
 
       conn_res = get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses")
@@ -3599,9 +3593,9 @@ test "GET /api/pleroma/admin/config/descriptions", %{conn: conn} do
     test "status visibility count", %{conn: conn} do
       admin = insert(:user, is_admin: true)
       user = insert(:user)
-      CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
-      CommonAPI.post(user, %{"visibility" => "unlisted", "status" => "hey"})
-      CommonAPI.post(user, %{"visibility" => "unlisted", "status" => "hey"})
+      CommonAPI.post(user, %{visibility: "public", status: "hey"})
+      CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
+      CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
 
       response =
         conn
diff --git a/test/web/admin_api/views/report_view_test.exs b/test/web/admin_api/views/report_view_test.exs
index 8cfa1dcfa..f00b0afb2 100644
--- a/test/web/admin_api/views/report_view_test.exs
+++ b/test/web/admin_api/views/report_view_test.exs
@@ -45,7 +45,7 @@ test "renders a report" do
   test "includes reported statuses" do
     user = insert(:user)
     other_user = insert(:user)
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "toot"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "toot"})
 
     {:ok, report_activity} =
       CommonAPI.report(user, %{account_id: other_user.id, status_ids: [activity.id]})
diff --git a/test/web/auth/basic_auth_test.exs b/test/web/auth/basic_auth_test.exs
index 64f8a6863..bf6e3d2fc 100644
--- a/test/web/auth/basic_auth_test.exs
+++ b/test/web/auth/basic_auth_test.exs
@@ -11,7 +11,7 @@ test "with HTTP Basic Auth used, grants access to OAuth scope-restricted endpoin
     conn: conn
   } do
     user = insert(:user)
-    assert Comeonin.Pbkdf2.checkpw("test", user.password_hash)
+    assert Pbkdf2.verify_pass("test", user.password_hash)
 
     basic_auth_contents =
       (URI.encode_www_form(user.nickname) <> ":" <> URI.encode_www_form("test"))
diff --git a/test/web/auth/pleroma_authenticator_test.exs b/test/web/auth/pleroma_authenticator_test.exs
index 7125c5081..5a421e5ed 100644
--- a/test/web/auth/pleroma_authenticator_test.exs
+++ b/test/web/auth/pleroma_authenticator_test.exs
@@ -11,7 +11,7 @@ defmodule Pleroma.Web.Auth.PleromaAuthenticatorTest do
   setup do
     password = "testpassword"
     name = "AgentSmith"
-    user = insert(:user, nickname: name, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
+    user = insert(:user, nickname: name, password_hash: Pbkdf2.hash_pwd_salt(password))
     {:ok, [user: user, name: name, password: password]}
   end
 
diff --git a/test/web/auth/totp_authenticator_test.exs b/test/web/auth/totp_authenticator_test.exs
index e08069490..e502e0ae8 100644
--- a/test/web/auth/totp_authenticator_test.exs
+++ b/test/web/auth/totp_authenticator_test.exs
@@ -34,7 +34,7 @@ test "checks backup codes" do
 
     hashed_codes =
       backup_codes
-      |> Enum.map(&Comeonin.Pbkdf2.hashpwsalt(&1))
+      |> Enum.map(&Pbkdf2.hash_pwd_salt(&1))
 
     user =
       insert(:user,
diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
index bc204e6e8..fd2c486a1 100644
--- a/test/web/common_api/common_api_test.exs
+++ b/test/web/common_api/common_api_test.exs
@@ -79,7 +79,7 @@ test "it reject messages over the local limit" do
     test "it works with pruned objects" do
       user = insert(:user)
 
-      {:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"})
+      {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
 
       Object.normalize(post, false)
       |> Object.prune()
@@ -97,7 +97,7 @@ test "it works with pruned objects" do
     test "it allows users to delete their posts" do
       user = insert(:user)
 
-      {:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"})
+      {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
 
       with_mock Pleroma.Web.Federator,
         publish: fn _ -> nil end do
@@ -113,7 +113,7 @@ test "it does not allow a user to delete their posts" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"})
+      {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
 
       assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
       assert Activity.get_by_id(post.id)
@@ -123,7 +123,7 @@ test "it allows moderators to delete other user's posts" do
       user = insert(:user)
       moderator = insert(:user, is_moderator: true)
 
-      {:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"})
+      {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
 
       assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
       assert delete.local
@@ -135,7 +135,7 @@ test "it allows admins to delete other user's posts" do
       user = insert(:user)
       moderator = insert(:user, is_admin: true)
 
-      {:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"})
+      {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
 
       assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
       assert delete.local
@@ -176,7 +176,7 @@ test "favoriting race condition" do
     users_serial = insert_list(10, :user)
     users = insert_list(10, :user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "."})
+    {:ok, activity} = CommonAPI.post(user, %{status: "."})
 
     users_serial
     |> Enum.map(fn user ->
@@ -203,7 +203,7 @@ test "repeating race condition" do
     users_serial = insert_list(10, :user)
     users = insert_list(10, :user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "."})
+    {:ok, activity} = CommonAPI.post(user, %{status: "."})
 
     users_serial
     |> Enum.map(fn user ->
@@ -227,12 +227,12 @@ test "repeating race condition" do
 
   test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+    {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
 
     [participation] = Participation.for_user(user)
 
     {:ok, convo_reply} =
-      CommonAPI.post(user, %{"status" => ".", "in_reply_to_conversation_id" => participation.id})
+      CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})
 
     assert Visibility.is_direct?(convo_reply)
 
@@ -246,8 +246,8 @@ test "when replying to a conversation / participation, it only mentions the reci
 
     {:ok, activity} =
       CommonAPI.post(har, %{
-        "status" => "@#{jafnhar.nickname} hey",
-        "visibility" => "direct"
+        status: "@#{jafnhar.nickname} hey",
+        visibility: "direct"
       })
 
     assert har.ap_id in activity.recipients
@@ -257,10 +257,10 @@ test "when replying to a conversation / participation, it only mentions the reci
 
     {:ok, activity} =
       CommonAPI.post(har, %{
-        "status" => "I don't really like @#{tridi.nickname}",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => activity.id,
-        "in_reply_to_conversation_id" => participation.id
+        status: "I don't really like @#{tridi.nickname}",
+        visibility: "direct",
+        in_reply_to_status_id: activity.id,
+        in_reply_to_conversation_id: participation.id
       })
 
     assert har.ap_id in activity.recipients
@@ -277,8 +277,8 @@ test "with the safe_dm_mention option set, it does not mention people beyond the
 
     {:ok, activity} =
       CommonAPI.post(har, %{
-        "status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
-        "visibility" => "direct"
+        status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
+        visibility: "direct"
       })
 
     refute tridi.ap_id in activity.recipients
@@ -287,7 +287,7 @@ test "with the safe_dm_mention option set, it does not mention people beyond the
 
   test "it de-duplicates tags" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})
 
     object = Object.normalize(activity)
 
@@ -296,7 +296,7 @@ test "it de-duplicates tags" do
 
   test "it adds emoji in the object" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})
+    {:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})
 
     assert Object.normalize(activity).data["emoji"]["firefox"]
   end
@@ -310,9 +310,9 @@ test "it supports explicit addressing" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" =>
+          status:
             "Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
-          "to" => [user_two.nickname, user_four.nickname, "nonexistent"]
+          to: [user_two.nickname, user_four.nickname, "nonexistent"]
         })
 
       assert user.ap_id in activity.recipients
@@ -328,8 +328,8 @@ test "it filters out obviously bad tags when accepting a post as HTML" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => post,
-          "content_type" => "text/html"
+          status: post,
+          content_type: "text/html"
         })
 
       object = Object.normalize(activity)
@@ -344,8 +344,8 @@ test "it filters out obviously bad tags when accepting a post as Markdown" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => post,
-          "content_type" => "text/markdown"
+          status: post,
+          content_type: "text/markdown"
         })
 
       object = Object.normalize(activity)
@@ -356,21 +356,21 @@ test "it filters out obviously bad tags when accepting a post as Markdown" do
     test "it does not allow replies to direct messages that are not direct messages themselves" do
       user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "suya..", visibility: "direct"})
 
       assert {:ok, _} =
                CommonAPI.post(user, %{
-                 "status" => "suya..",
-                 "visibility" => "direct",
-                 "in_reply_to_status_id" => activity.id
+                 status: "suya..",
+                 visibility: "direct",
+                 in_reply_to_status_id: activity.id
                })
 
       Enum.each(["public", "private", "unlisted"], fn visibility ->
         assert {:error, "The message visibility must be direct"} =
                  CommonAPI.post(user, %{
-                   "status" => "suya..",
-                   "visibility" => visibility,
-                   "in_reply_to_status_id" => activity.id
+                   status: "suya..",
+                   visibility: visibility,
+                   in_reply_to_status_id: activity.id
                  })
       end)
     end
@@ -379,8 +379,7 @@ test "it allows to address a list" do
       user = insert(:user)
       {:ok, list} = Pleroma.List.create("foo", user)
 
-      {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
 
       assert activity.data["bcc"] == [list.ap_id]
       assert activity.recipients == [list.ap_id, user.ap_id]
@@ -391,7 +390,7 @@ test "it returns error when status is empty and no attachments" do
       user = insert(:user)
 
       assert {:error, "Cannot post an empty status without attachments"} =
-               CommonAPI.post(user, %{"status" => ""})
+               CommonAPI.post(user, %{status: ""})
     end
 
     test "it validates character limits are correctly enforced" do
@@ -400,9 +399,9 @@ test "it validates character limits are correctly enforced" do
       user = insert(:user)
 
       assert {:error, "The status is over the character limit"} =
-               CommonAPI.post(user, %{"status" => "foobar"})
+               CommonAPI.post(user, %{status: "foobar"})
 
-      assert {:ok, activity} = CommonAPI.post(user, %{"status" => "12345"})
+      assert {:ok, activity} = CommonAPI.post(user, %{status: "12345"})
     end
 
     test "it can handle activities that expire" do
@@ -413,8 +412,7 @@ test "it can handle activities that expire" do
         |> NaiveDateTime.truncate(:second)
         |> NaiveDateTime.add(1_000_000, :second)
 
-      assert {:ok, activity} =
-               CommonAPI.post(user, %{"status" => "chai", "expires_in" => 1_000_000})
+      assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})
 
       assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id)
       assert expiration.scheduled_at == expires_at
@@ -426,14 +424,14 @@ test "reacting to a status with an emoji" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
 
       {:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")
 
       assert reaction.data["actor"] == user.ap_id
       assert reaction.data["content"] == "👍"
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
 
       {:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
     end
@@ -442,7 +440,7 @@ test "unreacting to a status with an emoji" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
       {:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")
 
       {:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")
@@ -456,7 +454,7 @@ test "repeating a status" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
 
       {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
     end
@@ -464,7 +462,7 @@ test "repeating a status" do
     test "can't repeat a repeat" do
       user = insert(:user)
       other_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
 
       {:ok, %Activity{} = announce, _} = CommonAPI.repeat(activity.id, other_user)
 
@@ -475,10 +473,10 @@ test "repeating a status privately" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
 
       {:ok, %Activity{} = announce_activity, _} =
-        CommonAPI.repeat(activity.id, user, %{"visibility" => "private"})
+        CommonAPI.repeat(activity.id, user, %{visibility: "private"})
 
       assert Visibility.is_private?(announce_activity)
     end
@@ -487,7 +485,7 @@ test "favoriting a status" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, post_activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, post_activity} = CommonAPI.post(other_user, %{status: "cofe"})
 
       {:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
       assert data["type"] == "Like"
@@ -499,7 +497,7 @@ test "retweeting a status twice returns the status" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
       {:ok, %Activity{} = announce, object} = CommonAPI.repeat(activity.id, user)
       {:ok, ^announce, ^object} = CommonAPI.repeat(activity.id, user)
     end
@@ -508,7 +506,7 @@ test "favoriting a status twice returns ok, but without the like activity" do
       user = insert(:user)
       other_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
       {:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
       assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
     end
@@ -519,7 +517,7 @@ test "favoriting a status twice returns ok, but without the like activity" do
       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
 
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
 
       [user: user, activity: activity]
     end
@@ -536,8 +534,8 @@ test "pin status", %{user: user, activity: activity} do
     test "pin poll", %{user: user} do
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "How is fediverse today?",
-          "poll" => %{"options" => ["Absolutely outstanding", "Not good"], "expires_in" => 20}
+          status: "How is fediverse today?",
+          poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
         })
 
       assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
@@ -549,7 +547,7 @@ test "pin poll", %{user: user} do
     end
 
     test "unlisted statuses can be pinned", %{user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!", "visibility" => "unlisted"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
       assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
     end
 
@@ -560,7 +558,7 @@ test "only self-authored can be pinned", %{activity: activity} do
     end
 
     test "max pinned statuses", %{user: user, activity: activity_one} do
-      {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
+      {:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})
 
       assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)
 
@@ -628,7 +626,7 @@ test "creates a report" do
       reporter = insert(:user)
       target_user = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
+      {:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
 
       reporter_ap_id = reporter.ap_id
       target_ap_id = target_user.ap_id
@@ -865,8 +863,8 @@ test "does not allow to vote twice" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "Am I cute?",
-          "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
+          status: "Am I cute?",
+          poll: %{options: ["Yes", "No"], expires_in: 20}
         })
 
       object = Object.normalize(activity)
diff --git a/test/web/common_api/common_api_utils_test.exs b/test/web/common_api/common_api_utils_test.exs
index 18a3b3b87..5708db6a4 100644
--- a/test/web/common_api/common_api_utils_test.exs
+++ b/test/web/common_api/common_api_utils_test.exs
@@ -228,7 +228,7 @@ test "for public posts, a reply" do
       user = insert(:user)
       mentioned_user = insert(:user)
       third_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"})
+      {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
       mentions = [mentioned_user.ap_id]
 
       {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "public", nil)
@@ -261,7 +261,7 @@ test "for unlisted posts, a reply" do
       user = insert(:user)
       mentioned_user = insert(:user)
       third_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"})
+      {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
       mentions = [mentioned_user.ap_id]
 
       {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "unlisted", nil)
@@ -292,7 +292,7 @@ test "for private posts, a reply" do
       user = insert(:user)
       mentioned_user = insert(:user)
       third_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"})
+      {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
       mentions = [mentioned_user.ap_id]
 
       {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "private", nil)
@@ -322,7 +322,7 @@ test "for direct posts, a reply" do
       user = insert(:user)
       mentioned_user = insert(:user)
       third_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"})
+      {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
       mentions = [mentioned_user.ap_id]
 
       {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "direct", nil)
@@ -463,8 +463,8 @@ test "returns attachments with descs" do
       desc = Jason.encode!(%{object.id => "test-desc"})
 
       assert Utils.attachments_from_ids(%{
-               "media_ids" => ["#{object.id}"],
-               "descriptions" => desc
+               media_ids: ["#{object.id}"],
+               descriptions: desc
              }) == [
                Map.merge(object.data, %{"name" => "test-desc"})
              ]
@@ -472,7 +472,7 @@ test "returns attachments with descs" do
 
     test "returns attachments without descs" do
       object = insert(:note)
-      assert Utils.attachments_from_ids(%{"media_ids" => ["#{object.id}"]}) == [object.data]
+      assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}) == [object.data]
     end
 
     test "returns [] when not pass media_ids" do
diff --git a/test/web/federator_test.exs b/test/web/federator_test.exs
index 261518ef0..de90aa6e0 100644
--- a/test/web/federator_test.exs
+++ b/test/web/federator_test.exs
@@ -29,7 +29,7 @@ defmodule Pleroma.Web.FederatorTest do
   describe "Publish an activity" do
     setup do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "HI"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
 
       relay_mock = {
         Pleroma.Web.ActivityPub.Relay,
@@ -96,7 +96,7 @@ test "it federates only to reachable instances via AP" do
       Instances.set_consistently_unreachable(URI.parse(inbox2).host)
 
       {:ok, _activity} =
-        CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})
+        CommonAPI.post(user, %{status: "HI @nick1@domain.com, @nick2@domain2.com!"})
 
       expected_dt = NaiveDateTime.to_iso8601(dt)
 
diff --git a/test/web/feed/tag_controller_test.exs b/test/web/feed/tag_controller_test.exs
index d95aac108..a54161bd4 100644
--- a/test/web/feed/tag_controller_test.exs
+++ b/test/web/feed/tag_controller_test.exs
@@ -21,7 +21,7 @@ test "gets a feed (ATOM)", %{conn: conn} do
     )
 
     user = insert(:user)
-    {:ok, activity1} = CommonAPI.post(user, %{"status" => "yeah #PleromaArt"})
+    {:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})
 
     object = Object.normalize(activity1)
 
@@ -43,9 +43,9 @@ test "gets a feed (ATOM)", %{conn: conn} do
     |> Ecto.Changeset.change(data: object_data)
     |> Pleroma.Repo.update()
 
-    {:ok, activity2} = CommonAPI.post(user, %{"status" => "42 This is :moominmamma #PleromaArt"})
+    {:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})
 
-    {:ok, _activity3} = CommonAPI.post(user, %{"status" => "This is :moominmamma"})
+    {:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})
 
     response =
       conn
@@ -88,7 +88,7 @@ test "gets a feed (RSS)", %{conn: conn} do
     )
 
     user = insert(:user)
-    {:ok, activity1} = CommonAPI.post(user, %{"status" => "yeah #PleromaArt"})
+    {:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})
 
     object = Object.normalize(activity1)
 
@@ -110,9 +110,9 @@ test "gets a feed (RSS)", %{conn: conn} do
     |> Ecto.Changeset.change(data: object_data)
     |> Pleroma.Repo.update()
 
-    {:ok, activity2} = CommonAPI.post(user, %{"status" => "42 This is :moominmamma #PleromaArt"})
+    {:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})
 
-    {:ok, _activity3} = CommonAPI.post(user, %{"status" => "This is :moominmamma"})
+    {:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})
 
     response =
       conn
diff --git a/test/web/mastodon_api/controllers/account_controller_test.exs b/test/web/mastodon_api/controllers/account_controller_test.exs
index 256a8b304..280bd6aca 100644
--- a/test/web/mastodon_api/controllers/account_controller_test.exs
+++ b/test/web/mastodon_api/controllers/account_controller_test.exs
@@ -222,13 +222,40 @@ test "if user is authenticated", %{local: local, remote: remote} do
   describe "user timelines" do
     setup do: oauth_access(["read:statuses"])
 
+    test "works with announces that are just addressed to public", %{conn: conn} do
+      user = insert(:user, ap_id: "https://honktest/u/test", local: false)
+      other_user = insert(:user)
+
+      {:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})
+
+      {:ok, announce, _} =
+        %{
+          "@context" => "https://www.w3.org/ns/activitystreams",
+          "actor" => "https://honktest/u/test",
+          "id" => "https://honktest/u/test/bonk/1793M7B9MQ48847vdx",
+          "object" => post.data["object"],
+          "published" => "2019-06-25T19:33:58Z",
+          "to" => ["https://www.w3.org/ns/activitystreams#Public"],
+          "type" => "Announce"
+        }
+        |> ActivityPub.persist(local: false)
+
+      assert resp =
+               conn
+               |> get("/api/v1/accounts/#{user.id}/statuses")
+               |> json_response_and_validate_schema(200)
+
+      assert [%{"id" => id}] = resp
+      assert id == announce.id
+    end
+
     test "respects blocks", %{user: user_one, conn: conn} do
       user_two = insert(:user)
       user_three = insert(:user)
 
       User.block(user_one, user_two)
 
-      {:ok, activity} = CommonAPI.post(user_two, %{"status" => "User one sux0rz"})
+      {:ok, activity} = CommonAPI.post(user_two, %{status: "User one sux0rz"})
       {:ok, repeat, _} = CommonAPI.repeat(activity.id, user_three)
 
       assert resp =
@@ -271,16 +298,16 @@ test "gets users statuses", %{conn: conn} do
 
       {:ok, _user_three} = User.follow(user_three, user_one)
 
-      {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
+      {:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!"})
 
       {:ok, direct_activity} =
         CommonAPI.post(user_one, %{
-          "status" => "Hi, @#{user_two.nickname}.",
-          "visibility" => "direct"
+          status: "Hi, @#{user_two.nickname}.",
+          visibility: "direct"
         })
 
       {:ok, private_activity} =
-        CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
+        CommonAPI.post(user_one, %{status: "private", visibility: "private"})
 
       # TODO!!!
       resp =
@@ -335,8 +362,7 @@ test "gets an users media", %{conn: conn} do
 
       {:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)
 
-      {:ok, %{id: image_post_id}} =
-        CommonAPI.post(user, %{"status" => "cofe", "media_ids" => [media_id]})
+      {:ok, %{id: image_post_id}} = CommonAPI.post(user, %{status: "cofe", media_ids: [media_id]})
 
       conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_media=true")
 
@@ -348,7 +374,7 @@ test "gets an users media", %{conn: conn} do
     end
 
     test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
-      {:ok, %{id: post_id}} = CommonAPI.post(user, %{"status" => "HI!!!"})
+      {:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
       {:ok, _, _} = CommonAPI.repeat(post_id, user)
 
       conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true")
@@ -359,8 +385,8 @@ test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
     end
 
     test "filters user's statuses by a hashtag", %{user: user, conn: conn} do
-      {:ok, %{id: post_id}} = CommonAPI.post(user, %{"status" => "#hashtag"})
-      {:ok, _post} = CommonAPI.post(user, %{"status" => "hashtag"})
+      {:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "#hashtag"})
+      {:ok, _post} = CommonAPI.post(user, %{status: "hashtag"})
 
       conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag")
       assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
@@ -371,9 +397,9 @@ test "the user views their own timelines and excludes direct messages", %{
       conn: conn
     } do
       {:ok, %{id: public_activity_id}} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
+        CommonAPI.post(user, %{status: ".", visibility: "public"})
 
-      {:ok, _direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+      {:ok, _direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
 
       conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct")
       assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200)
@@ -651,7 +677,7 @@ test "following without reblogs" do
 
       assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200)
 
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
       {:ok, %{id: reblog_id}, _} = CommonAPI.repeat(activity.id, followed)
 
       assert [] ==
@@ -750,7 +776,7 @@ test "without notifications", %{conn: conn} do
   describe "pinned statuses" do
     setup do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
       %{conn: conn} = oauth_access(["read:statuses"], user: user)
 
       [conn: conn, user: user, activity: activity]
diff --git a/test/web/mastodon_api/controllers/conversation_controller_test.exs b/test/web/mastodon_api/controllers/conversation_controller_test.exs
index 04695572e..693ba51e5 100644
--- a/test/web/mastodon_api/controllers/conversation_controller_test.exs
+++ b/test/web/mastodon_api/controllers/conversation_controller_test.exs
@@ -22,16 +22,16 @@ test "returns a list of conversations", %{user: user_one, conn: conn} do
 
     {:ok, direct} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
+        visibility: "direct"
       })
 
     assert User.get_cached_by_id(user_two.id).unread_conversation_count == 1
 
     {:ok, _follower_only} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}!",
-        "visibility" => "private"
+        status: "Hi @#{user_two.nickname}!",
+        visibility: "private"
       })
 
     res_conn = get(conn, "/api/v1/conversations")
@@ -63,32 +63,32 @@ test "filters conversations by recipients", %{user: user_one, conn: conn} do
 
     {:ok, direct1} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_two.nickname}!",
+        visibility: "direct"
       })
 
     {:ok, _direct2} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_three.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_three.nickname}!",
+        visibility: "direct"
       })
 
     {:ok, direct3} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
+        visibility: "direct"
       })
 
     {:ok, _direct4} =
       CommonAPI.post(user_two, %{
-        "status" => "Hi @#{user_three.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_three.nickname}!",
+        visibility: "direct"
       })
 
     {:ok, direct5} =
       CommonAPI.post(user_two, %{
-        "status" => "Hi @#{user_one.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_one.nickname}!",
+        visibility: "direct"
       })
 
     assert [conversation1, conversation2] =
@@ -112,15 +112,15 @@ test "updates the last_status on reply", %{user: user_one, conn: conn} do
 
     {:ok, direct} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}",
-        "visibility" => "direct"
+        status: "Hi @#{user_two.nickname}",
+        visibility: "direct"
       })
 
     {:ok, direct_reply} =
       CommonAPI.post(user_two, %{
-        "status" => "reply",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => direct.id
+        status: "reply",
+        visibility: "direct",
+        in_reply_to_status_id: direct.id
       })
 
     [%{"last_status" => res_last_status}] =
@@ -136,8 +136,8 @@ test "the user marks a conversation as read", %{user: user_one, conn: conn} do
 
     {:ok, direct} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}",
-        "visibility" => "direct"
+        status: "Hi @#{user_two.nickname}",
+        visibility: "direct"
       })
 
     assert User.get_cached_by_id(user_one.id).unread_conversation_count == 0
@@ -167,9 +167,9 @@ test "the user marks a conversation as read", %{user: user_one, conn: conn} do
     # The conversation is marked as unread on reply
     {:ok, _} =
       CommonAPI.post(user_two, %{
-        "status" => "reply",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => direct.id
+        status: "reply",
+        visibility: "direct",
+        in_reply_to_status_id: direct.id
       })
 
     [%{"unread" => true}] =
@@ -183,9 +183,9 @@ test "the user marks a conversation as read", %{user: user_one, conn: conn} do
     # A reply doesn't increment the user's unread_conversation_count if the conversation is unread
     {:ok, _} =
       CommonAPI.post(user_two, %{
-        "status" => "reply",
-        "visibility" => "direct",
-        "in_reply_to_status_id" => direct.id
+        status: "reply",
+        visibility: "direct",
+        in_reply_to_status_id: direct.id
       })
 
     assert User.get_cached_by_id(user_one.id).unread_conversation_count == 1
@@ -197,8 +197,8 @@ test "(vanilla) Mastodon frontend behaviour", %{user: user_one, conn: conn} do
 
     {:ok, direct} =
       CommonAPI.post(user_one, %{
-        "status" => "Hi @#{user_two.nickname}!",
-        "visibility" => "direct"
+        status: "Hi @#{user_two.nickname}!",
+        visibility: "direct"
       })
 
     res_conn = get(conn, "/api/v1/statuses/#{direct.id}/context")
diff --git a/test/web/mastodon_api/controllers/instance_controller_test.exs b/test/web/mastodon_api/controllers/instance_controller_test.exs
index 90840d5ab..2c61dc5ba 100644
--- a/test/web/mastodon_api/controllers/instance_controller_test.exs
+++ b/test/web/mastodon_api/controllers/instance_controller_test.exs
@@ -50,7 +50,7 @@ test "get instance stats", %{conn: conn} do
     insert(:user, %{local: false, nickname: "u@peer1.com"})
     insert(:user, %{local: false, nickname: "u@peer2.com"})
 
-    {:ok, _} = Pleroma.Web.CommonAPI.post(user, %{"status" => "cofe"})
+    {:ok, _} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
 
     Pleroma.Stats.force_update()
 
diff --git a/test/web/mastodon_api/controllers/notification_controller_test.exs b/test/web/mastodon_api/controllers/notification_controller_test.exs
index db380f76a..d9356a844 100644
--- a/test/web/mastodon_api/controllers/notification_controller_test.exs
+++ b/test/web/mastodon_api/controllers/notification_controller_test.exs
@@ -18,7 +18,7 @@ test "does NOT render account/pleroma/relationship if this is disabled by defaul
     %{user: user, conn: conn} = oauth_access(["read:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
     {:ok, [_notification]} = Notification.create_notifications(activity)
 
     response =
@@ -36,7 +36,7 @@ test "list of notifications" do
     %{user: user, conn: conn} = oauth_access(["read:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
     {:ok, [_notification]} = Notification.create_notifications(activity)
 
@@ -60,7 +60,7 @@ test "getting a single notification" do
     %{user: user, conn: conn} = oauth_access(["read:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
     {:ok, [notification]} = Notification.create_notifications(activity)
 
@@ -79,7 +79,7 @@ test "dismissing a single notification (deprecated endpoint)" do
     %{user: user, conn: conn} = oauth_access(["write:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
     {:ok, [notification]} = Notification.create_notifications(activity)
 
@@ -96,7 +96,7 @@ test "dismissing a single notification" do
     %{user: user, conn: conn} = oauth_access(["write:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
     {:ok, [notification]} = Notification.create_notifications(activity)
 
@@ -112,7 +112,7 @@ test "clearing all notifications" do
     %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
     {:ok, [_notification]} = Notification.create_notifications(activity)
 
@@ -130,10 +130,10 @@ test "paginates notifications using min_id, since_id, max_id, and limit" do
     %{user: user, conn: conn} = oauth_access(["read:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
-    {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
-    {:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
-    {:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+    {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
+    {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
+    {:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
+    {:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
     notification1_id = get_notification_id_by_activity(activity1)
     notification2_id = get_notification_id_by_activity(activity2)
@@ -173,16 +173,16 @@ test "filters notifications for mentions" do
       other_user = insert(:user)
 
       {:ok, public_activity} =
-        CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"})
+        CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})
 
       {:ok, direct_activity} =
-        CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
+        CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 
       {:ok, unlisted_activity} =
-        CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"})
+        CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})
 
       {:ok, private_activity} =
-        CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"})
+        CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})
 
       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
       conn_res = get(conn, "/api/v1/notifications?" <> query)
@@ -213,17 +213,15 @@ test "filters notifications for Like activities" do
       user = insert(:user)
       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 
-      {:ok, public_activity} =
-        CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
+      {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 
       {:ok, direct_activity} =
-        CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
+        CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 
       {:ok, unlisted_activity} =
-        CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
+        CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 
-      {:ok, private_activity} =
-        CommonAPI.post(other_user, %{"status" => ".", "visibility" => "private"})
+      {:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})
 
       {:ok, _} = CommonAPI.favorite(user, public_activity.id)
       {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
@@ -279,11 +277,10 @@ test "filters notifications for Announce activities" do
       user = insert(:user)
       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 
-      {:ok, public_activity} =
-        CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
+      {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 
       {:ok, unlisted_activity} =
-        CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
+        CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 
       {:ok, _, _} = CommonAPI.repeat(public_activity.id, user)
       {:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user)
@@ -303,8 +300,8 @@ test "filters notifications using exclude_types" do
     %{user: user, conn: conn} = oauth_access(["read:notifications"])
     other_user = insert(:user)
 
-    {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
-    {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
+    {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
+    {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
     {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
@@ -341,8 +338,8 @@ test "filters notifications using include_types" do
     %{user: user, conn: conn} = oauth_access(["read:notifications"])
     other_user = insert(:user)
 
-    {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
-    {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
+    {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
+    {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
     {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
@@ -388,10 +385,10 @@ test "destroy multiple" do
     %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
     other_user = insert(:user)
 
-    {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
-    {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
-    {:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
-    {:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
+    {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
+    {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
+    {:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
+    {:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 
     notification1_id = get_notification_id_by_activity(activity1)
     notification2_id = get_notification_id_by_activity(activity2)
@@ -435,7 +432,7 @@ test "doesn't see notifications after muting user with notifications" do
     user2 = insert(:user)
 
     {:ok, _, _, _} = CommonAPI.follow(user, user2)
-    {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
+    {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 
     ret_conn = get(conn, "/api/v1/notifications")
 
@@ -453,7 +450,7 @@ test "see notifications after muting user without notifications" do
     user2 = insert(:user)
 
     {:ok, _, _, _} = CommonAPI.follow(user, user2)
-    {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
+    {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 
     ret_conn = get(conn, "/api/v1/notifications")
 
@@ -471,7 +468,7 @@ test "see notifications after muting user with notifications and with_muted para
     user2 = insert(:user)
 
     {:ok, _, _, _} = CommonAPI.follow(user, user2)
-    {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
+    {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 
     ret_conn = get(conn, "/api/v1/notifications")
 
@@ -518,14 +515,14 @@ test "preserves parameters in link headers" do
 
       {:ok, activity1} =
         CommonAPI.post(other_user, %{
-          "status" => "hi @#{user.nickname}",
-          "visibility" => "public"
+          status: "hi @#{user.nickname}",
+          visibility: "public"
         })
 
       {:ok, activity2} =
         CommonAPI.post(other_user, %{
-          "status" => "hi @#{user.nickname}",
-          "visibility" => "public"
+          status: "hi @#{user.nickname}",
+          visibility: "public"
         })
 
       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
@@ -550,8 +547,8 @@ test "account_id" do
       %{id: account_id} = other_user1 = insert(:user)
       other_user2 = insert(:user)
 
-      {:ok, _activity} = CommonAPI.post(other_user1, %{"status" => "hi @#{user.nickname}"})
-      {:ok, _activity} = CommonAPI.post(other_user2, %{"status" => "bye @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})
 
       assert [%{"account" => %{"id" => ^account_id}}] =
                conn
diff --git a/test/web/mastodon_api/controllers/poll_controller_test.exs b/test/web/mastodon_api/controllers/poll_controller_test.exs
index d8f34aa86..f41de6448 100644
--- a/test/web/mastodon_api/controllers/poll_controller_test.exs
+++ b/test/web/mastodon_api/controllers/poll_controller_test.exs
@@ -16,8 +16,8 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
     test "returns poll entity for object id", %{user: user, conn: conn} do
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "Pleroma does",
-          "poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20}
+          status: "Pleroma does",
+          poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20}
         })
 
       object = Object.normalize(activity)
@@ -34,9 +34,9 @@ test "does not expose polls for private statuses", %{conn: conn} do
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
-          "status" => "Pleroma does",
-          "poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20},
-          "visibility" => "private"
+          status: "Pleroma does",
+          poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20},
+          visibility: "private"
         })
 
       object = Object.normalize(activity)
@@ -55,11 +55,11 @@ test "votes are added to the poll", %{conn: conn} do
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
-          "status" => "A very delicious sandwich",
-          "poll" => %{
-            "options" => ["Lettuce", "Grilled Bacon", "Tomato"],
-            "expires_in" => 20,
-            "multiple" => true
+          status: "A very delicious sandwich",
+          poll: %{
+            options: ["Lettuce", "Grilled Bacon", "Tomato"],
+            expires_in: 20,
+            multiple: true
           }
         })
 
@@ -81,8 +81,8 @@ test "votes are added to the poll", %{conn: conn} do
     test "author can't vote", %{user: user, conn: conn} do
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "Am I cute?",
-          "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
+          status: "Am I cute?",
+          poll: %{options: ["Yes", "No"], expires_in: 20}
         })
 
       object = Object.normalize(activity)
@@ -102,8 +102,8 @@ test "does not allow multiple choices on a single-choice question", %{conn: conn
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
-          "status" => "The glass is",
-          "poll" => %{"options" => ["half empty", "half full"], "expires_in" => 20}
+          status: "The glass is",
+          poll: %{options: ["half empty", "half full"], expires_in: 20}
         })
 
       object = Object.normalize(activity)
@@ -125,8 +125,8 @@ test "does not allow choice index to be greater than options count", %{conn: con
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
-          "status" => "Am I cute?",
-          "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
+          status: "Am I cute?",
+          poll: %{options: ["Yes", "No"], expires_in: 20}
         })
 
       object = Object.normalize(activity)
@@ -153,9 +153,9 @@ test "returns 404 when poll is private and not available for user", %{conn: conn
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
-          "status" => "Am I cute?",
-          "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20},
-          "visibility" => "private"
+          status: "Am I cute?",
+          poll: %{options: ["Yes", "No"], expires_in: 20},
+          visibility: "private"
         })
 
       object = Object.normalize(activity)
diff --git a/test/web/mastodon_api/controllers/report_controller_test.exs b/test/web/mastodon_api/controllers/report_controller_test.exs
index 21b037237..6636cff96 100644
--- a/test/web/mastodon_api/controllers/report_controller_test.exs
+++ b/test/web/mastodon_api/controllers/report_controller_test.exs
@@ -14,7 +14,7 @@ defmodule Pleroma.Web.MastodonAPI.ReportControllerTest do
   setup do
     target_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
+    {:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
 
     [target_user: target_user, activity: activity]
   end
diff --git a/test/web/mastodon_api/controllers/search_controller_test.exs b/test/web/mastodon_api/controllers/search_controller_test.exs
index 02476acb6..6ad9a59fe 100644
--- a/test/web/mastodon_api/controllers/search_controller_test.exs
+++ b/test/web/mastodon_api/controllers/search_controller_test.exs
@@ -42,15 +42,15 @@ test "search", %{conn: conn} do
       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu private 天子"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
-          "status" => "This is about 2hu, but private",
-          "visibility" => "private"
+          status: "This is about 2hu, but private",
+          visibility: "private"
         })
 
-      {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
+      {:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})
 
       results =
         conn
@@ -80,9 +80,9 @@ test "excludes a blocked users from search results", %{conn: conn} do
       user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
       user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})
 
-      {:ok, act1} = CommonAPI.post(user, %{"status" => "This is about 2hu private 天子"})
-      {:ok, act2} = CommonAPI.post(user_smith, %{"status" => "Agent Smith"})
-      {:ok, act3} = CommonAPI.post(user_neo, %{"status" => "Agent Smith"})
+      {:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
+      {:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
+      {:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
       Pleroma.User.block(user, user_smith)
 
       results =
@@ -161,15 +161,15 @@ test "search", %{conn: conn} do
       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
       user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
-          "status" => "This is about 2hu, but private",
-          "visibility" => "private"
+          status: "This is about 2hu, but private",
+          visibility: "private"
         })
 
-      {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
+      {:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})
 
       results =
         conn
@@ -189,7 +189,7 @@ test "search fetches remote statuses and prefers them over other results", %{con
       capture_log(fn ->
         {:ok, %{id: activity_id}} =
           CommonAPI.post(insert(:user), %{
-            "status" => "check out https://shitposter.club/notice/2827873"
+            status: "check out https://shitposter.club/notice/2827873"
           })
 
         results =
@@ -207,8 +207,8 @@ test "search fetches remote statuses and prefers them over other results", %{con
     test "search doesn't show statuses that it shouldn't", %{conn: conn} do
       {:ok, activity} =
         CommonAPI.post(insert(:user), %{
-          "status" => "This is about 2hu, but private",
-          "visibility" => "private"
+          status: "This is about 2hu, but private",
+          visibility: "private"
         })
 
       capture_log(fn ->
@@ -251,8 +251,8 @@ test "search with limit and offset", %{conn: conn} do
       _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
       _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 
-      {:ok, _activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
-      {:ok, _activity2} = CommonAPI.post(user, %{"status" => "This is also about 2hu"})
+      {:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
+      {:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})
 
       result =
         conn
@@ -277,7 +277,7 @@ test "search returns results only for the given type", %{conn: conn} do
       user = insert(:user)
       _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
 
       assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
                conn
@@ -294,8 +294,8 @@ test "search uses account_id to filter statuses by the author", %{conn: conn} do
       user = insert(:user, %{nickname: "shp@shitposter.club"})
       user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 
-      {:ok, activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
-      {:ok, activity2} = CommonAPI.post(user_two, %{"status" => "This is also about 2hu"})
+      {:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
+      {:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})
 
       results =
         conn
diff --git a/test/web/mastodon_api/controllers/status_controller_test.exs b/test/web/mastodon_api/controllers/status_controller_test.exs
index 85068edd0..a4403132c 100644
--- a/test/web/mastodon_api/controllers/status_controller_test.exs
+++ b/test/web/mastodon_api/controllers/status_controller_test.exs
@@ -32,13 +32,14 @@ test "posting a status does not increment reblog_count when relaying", %{conn: c
 
       response =
         conn
+        |> put_req_header("content-type", "application/json")
         |> post("api/v1/statuses", %{
           "content_type" => "text/plain",
           "source" => "Pleroma FE",
           "status" => "Hello world",
           "visibility" => "public"
         })
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       assert response["reblogs_count"] == 0
       ObanHelpers.perform_all()
@@ -46,7 +47,7 @@ test "posting a status does not increment reblog_count when relaying", %{conn: c
       response =
         conn
         |> get("api/v1/statuses/#{response["id"]}", %{})
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       assert response["reblogs_count"] == 0
     end
@@ -56,6 +57,7 @@ test "posting a status", %{conn: conn} do
 
       conn_one =
         conn
+        |> put_req_header("content-type", "application/json")
         |> put_req_header("idempotency-key", idempotency_key)
         |> post("/api/v1/statuses", %{
           "status" => "cofe",
@@ -68,12 +70,13 @@ test "posting a status", %{conn: conn} do
       assert ttl > :timer.seconds(6 * 60 * 60 - 1)
 
       assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
-               json_response(conn_one, 200)
+               json_response_and_validate_schema(conn_one, 200)
 
       assert Activity.get_by_id(id)
 
       conn_two =
         conn
+        |> put_req_header("content-type", "application/json")
         |> put_req_header("idempotency-key", idempotency_key)
         |> post("/api/v1/statuses", %{
           "status" => "cofe",
@@ -86,13 +89,14 @@ test "posting a status", %{conn: conn} do
 
       conn_three =
         conn
+        |> put_req_header("content-type", "application/json")
         |> post("/api/v1/statuses", %{
           "status" => "cofe",
           "spoiler_text" => "2hu",
           "sensitive" => "false"
         })
 
-      assert %{"id" => third_id} = json_response(conn_three, 200)
+      assert %{"id" => third_id} = json_response_and_validate_schema(conn_three, 200)
       refute id == third_id
 
       # An activity that will expire:
@@ -101,12 +105,15 @@ test "posting a status", %{conn: conn} do
 
       conn_four =
         conn
+        |> put_req_header("content-type", "application/json")
         |> post("api/v1/statuses", %{
           "status" => "oolong",
           "expires_in" => expires_in
         })
 
-      assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
+      assert fourth_response =
+               %{"id" => fourth_id} = json_response_and_validate_schema(conn_four, 200)
+
       assert activity = Activity.get_by_id(fourth_id)
       assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)
 
@@ -130,22 +137,24 @@ test "it fails to create a status if `expires_in` is less or equal than an hour"
 
       assert %{"error" => "Expiry date is too soon"} =
                conn
+               |> put_req_header("content-type", "application/json")
                |> post("api/v1/statuses", %{
                  "status" => "oolong",
                  "expires_in" => expires_in
                })
-               |> json_response(422)
+               |> json_response_and_validate_schema(422)
 
       # 30 minutes
       expires_in = 30 * 60
 
       assert %{"error" => "Expiry date is too soon"} =
                conn
+               |> put_req_header("content-type", "application/json")
                |> post("api/v1/statuses", %{
                  "status" => "oolong",
                  "expires_in" => expires_in
                })
-               |> json_response(422)
+               |> json_response_and_validate_schema(422)
     end
 
     test "posting an undefined status with an attachment", %{user: user, conn: conn} do
@@ -158,21 +167,24 @@ test "posting an undefined status with an attachment", %{user: user, conn: conn}
       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "media_ids" => [to_string(upload.id)]
         })
 
-      assert json_response(conn, 200)
+      assert json_response_and_validate_schema(conn, 200)
     end
 
     test "replying to a status", %{user: user, conn: conn} do
-      {:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})
+      {:ok, replied_to} = CommonAPI.post(user, %{status: "cofe"})
 
       conn =
         conn
+        |> put_req_header("content-type", "application/json")
         |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 
-      assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
+      assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)
 
       activity = Activity.get_by_id(id)
 
@@ -184,43 +196,56 @@ test "replying to a direct message with visibility other than direct", %{
       user: user,
       conn: conn
     } do
-      {:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
+      {:ok, replied_to} = CommonAPI.post(user, %{status: "suya..", visibility: "direct"})
 
       Enum.each(["public", "private", "unlisted"], fn visibility ->
         conn =
           conn
+          |> put_req_header("content-type", "application/json")
           |> post("/api/v1/statuses", %{
             "status" => "@#{user.nickname} hey",
             "in_reply_to_id" => replied_to.id,
             "visibility" => visibility
           })
 
-        assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
+        assert json_response_and_validate_schema(conn, 422) == %{
+                 "error" => "The message visibility must be direct"
+               }
       end)
     end
 
     test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
-      conn = post(conn, "/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 
-      assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
+      assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)
       assert Activity.get_by_id(id)
     end
 
     test "posting a sensitive status", %{conn: conn} do
-      conn = post(conn, "/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
+
+      assert %{"content" => "cofe", "id" => id, "sensitive" => true} =
+               json_response_and_validate_schema(conn, 200)
 
-      assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
       assert Activity.get_by_id(id)
     end
 
     test "posting a fake status", %{conn: conn} do
       real_conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" =>
             "\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
         })
 
-      real_status = json_response(real_conn, 200)
+      real_status = json_response_and_validate_schema(real_conn, 200)
 
       assert real_status
       assert Object.get_by_ap_id(real_status["uri"])
@@ -234,13 +259,15 @@ test "posting a fake status", %{conn: conn} do
         |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 
       fake_conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" =>
             "\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
           "preview" => true
         })
 
-      fake_status = json_response(fake_conn, 200)
+      fake_status = json_response_and_validate_schema(fake_conn, 200)
 
       assert fake_status
       refute Object.get_by_ap_id(fake_status["uri"])
@@ -261,11 +288,15 @@ test "posting a status with OGP link preview", %{conn: conn} do
       Config.put([:rich_media, :enabled], true)
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "https://example.com/ogp"
         })
 
-      assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
+      assert %{"id" => id, "card" => %{"title" => "The Rock"}} =
+               json_response_and_validate_schema(conn, 200)
+
       assert Activity.get_by_id(id)
     end
 
@@ -273,9 +304,12 @@ test "posting a direct status", %{conn: conn} do
       user2 = insert(:user)
       content = "direct cofe @#{user2.nickname}"
 
-      conn = post(conn, "api/v1/statuses", %{"status" => content, "visibility" => "direct"})
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 
-      assert %{"id" => id} = response = json_response(conn, 200)
+      assert %{"id" => id} = response = json_response_and_validate_schema(conn, 200)
       assert response["visibility"] == "direct"
       assert response["pleroma"]["direct_conversation_id"]
       assert activity = Activity.get_by_id(id)
@@ -289,32 +323,45 @@ test "posting a direct status", %{conn: conn} do
     setup do: oauth_access(["write:statuses"])
 
     test "creates a scheduled activity", %{conn: conn} do
-      scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
+      scheduled_at =
+        NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
+        |> NaiveDateTime.to_iso8601()
+        |> Kernel.<>("Z")
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "scheduled",
           "scheduled_at" => scheduled_at
         })
 
-      assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
+      assert %{"scheduled_at" => expected_scheduled_at} =
+               json_response_and_validate_schema(conn, 200)
+
       assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
       assert [] == Repo.all(Activity)
     end
 
     test "ignores nil values", %{conn: conn} do
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "not scheduled",
           "scheduled_at" => nil
         })
 
-      assert result = json_response(conn, 200)
+      assert result = json_response_and_validate_schema(conn, 200)
       assert Activity.get_by_id(result["id"])
     end
 
     test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
-      scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
+      scheduled_at =
+        NaiveDateTime.utc_now()
+        |> NaiveDateTime.add(:timer.minutes(120), :millisecond)
+        |> NaiveDateTime.to_iso8601()
+        |> Kernel.<>("Z")
 
       file = %Plug.Upload{
         content_type: "image/jpg",
@@ -325,13 +372,17 @@ test "creates a scheduled activity with a media attachment", %{user: user, conn:
       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "media_ids" => [to_string(upload.id)],
           "status" => "scheduled",
           "scheduled_at" => scheduled_at
         })
 
-      assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
+      assert %{"media_attachments" => [media_attachment]} =
+               json_response_and_validate_schema(conn, 200)
+
       assert %{"type" => "image"} = media_attachment
     end
 
@@ -339,14 +390,18 @@ test "skips the scheduling and creates the activity if scheduled_at is earlier t
          %{conn: conn} do
       scheduled_at =
         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
+        |> NaiveDateTime.to_iso8601()
+        |> Kernel.<>("Z")
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "not scheduled",
           "scheduled_at" => scheduled_at
         })
 
-      assert %{"content" => "not scheduled"} = json_response(conn, 200)
+      assert %{"content" => "not scheduled"} = json_response_and_validate_schema(conn, 200)
       assert [] == Repo.all(ScheduledActivity)
     end
 
@@ -355,14 +410,19 @@ test "returns error when daily user limit is exceeded", %{user: user, conn: conn
         NaiveDateTime.utc_now()
         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
         |> NaiveDateTime.to_iso8601()
+        # TODO
+        |> Kernel.<>("Z")
 
       attrs = %{params: %{}, scheduled_at: today}
       {:ok, _} = ScheduledActivity.create(user, attrs)
       {:ok, _} = ScheduledActivity.create(user, attrs)
 
-      conn = post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
 
-      assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
+      assert %{"error" => "daily limit exceeded"} == json_response_and_validate_schema(conn, 422)
     end
 
     test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
@@ -370,11 +430,13 @@ test "returns error when total user limit is exceeded", %{user: user, conn: conn
         NaiveDateTime.utc_now()
         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
         |> NaiveDateTime.to_iso8601()
+        |> Kernel.<>("Z")
 
       tomorrow =
         NaiveDateTime.utc_now()
         |> NaiveDateTime.add(:timer.hours(36), :millisecond)
         |> NaiveDateTime.to_iso8601()
+        |> Kernel.<>("Z")
 
       attrs = %{params: %{}, scheduled_at: today}
       {:ok, _} = ScheduledActivity.create(user, attrs)
@@ -382,9 +444,11 @@ test "returns error when total user limit is exceeded", %{user: user, conn: conn
       {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
 
       conn =
-        post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
 
-      assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
+      assert %{"error" => "total limit exceeded"} == json_response_and_validate_schema(conn, 422)
     end
   end
 
@@ -395,12 +459,17 @@ test "posting a poll", %{conn: conn} do
       time = NaiveDateTime.utc_now()
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "Who is the #bestgrill?",
-          "poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
+          "poll" => %{
+            "options" => ["Rei", "Asuka", "Misato"],
+            "expires_in" => 420
+          }
         })
 
-      response = json_response(conn, 200)
+      response = json_response_and_validate_schema(conn, 200)
 
       assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
                title in ["Rei", "Asuka", "Misato"]
@@ -419,12 +488,14 @@ test "option limit is enforced", %{conn: conn} do
       limit = Config.get([:instance, :poll_limits, :max_options])
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "desu~",
           "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
         })
 
-      %{"error" => error} = json_response(conn, 422)
+      %{"error" => error} = json_response_and_validate_schema(conn, 422)
       assert error == "Poll can't contain more than #{limit} options"
     end
 
@@ -432,7 +503,9 @@ test "option character limit is enforced", %{conn: conn} do
       limit = Config.get([:instance, :poll_limits, :max_option_chars])
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "...",
           "poll" => %{
             "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
@@ -440,7 +513,7 @@ test "option character limit is enforced", %{conn: conn} do
           }
         })
 
-      %{"error" => error} = json_response(conn, 422)
+      %{"error" => error} = json_response_and_validate_schema(conn, 422)
       assert error == "Poll options cannot be longer than #{limit} characters each"
     end
 
@@ -448,7 +521,9 @@ test "minimal date limit is enforced", %{conn: conn} do
       limit = Config.get([:instance, :poll_limits, :min_expiration])
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "imagine arbitrary limits",
           "poll" => %{
             "options" => ["this post was made by pleroma gang"],
@@ -456,7 +531,7 @@ test "minimal date limit is enforced", %{conn: conn} do
           }
         })
 
-      %{"error" => error} = json_response(conn, 422)
+      %{"error" => error} = json_response_and_validate_schema(conn, 422)
       assert error == "Expiration date is too soon"
     end
 
@@ -464,7 +539,9 @@ test "maximum date limit is enforced", %{conn: conn} do
       limit = Config.get([:instance, :poll_limits, :max_expiration])
 
       conn =
-        post(conn, "/api/v1/statuses", %{
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses", %{
           "status" => "imagine arbitrary limits",
           "poll" => %{
             "options" => ["this post was made by pleroma gang"],
@@ -472,7 +549,7 @@ test "maximum date limit is enforced", %{conn: conn} do
           }
         })
 
-      %{"error" => error} = json_response(conn, 422)
+      %{"error" => error} = json_response_and_validate_schema(conn, 422)
       assert error == "Expiration date is too far in the future"
     end
   end
@@ -483,7 +560,7 @@ test "get a status" do
 
     conn = get(conn, "/api/v1/statuses/#{activity.id}")
 
-    assert %{"id" => id} = json_response(conn, 200)
+    assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
     assert id == to_string(activity.id)
   end
 
@@ -503,13 +580,13 @@ defp local_and_remote_activities do
     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 
-      assert json_response(res_conn, :not_found) == %{
+      assert json_response_and_validate_schema(res_conn, :not_found) == %{
                "error" => "Record not found"
              }
 
       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 
-      assert json_response(res_conn, :not_found) == %{
+      assert json_response_and_validate_schema(res_conn, :not_found) == %{
                "error" => "Record not found"
              }
     end
@@ -517,10 +594,10 @@ test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} d
     test "if user is authenticated", %{local: local, remote: remote} do
       %{conn: conn} = oauth_access(["read"])
       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
 
       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
     end
   end
 
@@ -532,21 +609,21 @@ test "if user is authenticated", %{local: local, remote: remote} do
     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 
-      assert json_response(res_conn, :not_found) == %{
+      assert json_response_and_validate_schema(res_conn, :not_found) == %{
                "error" => "Record not found"
              }
 
       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
     end
 
     test "if user is authenticated", %{local: local, remote: remote} do
       %{conn: conn} = oauth_access(["read"])
       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
 
       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
     end
   end
 
@@ -557,11 +634,11 @@ test "if user is authenticated", %{local: local, remote: remote} do
 
     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
 
       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 
-      assert json_response(res_conn, :not_found) == %{
+      assert json_response_and_validate_schema(res_conn, :not_found) == %{
                "error" => "Record not found"
              }
     end
@@ -569,10 +646,10 @@ test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} d
     test "if user is authenticated", %{local: local, remote: remote} do
       %{conn: conn} = oauth_access(["read"])
       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
 
       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
-      assert %{"id" => _} = json_response(res_conn, 200)
+      assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
     end
   end
 
@@ -582,7 +659,7 @@ test "getting a status that doesn't exist returns 404" do
 
     conn = get(conn, "/api/v1/statuses/#{String.downcase(activity.id)}")
 
-    assert json_response(conn, 404) == %{"error" => "Record not found"}
+    assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
   end
 
   test "get a direct status" do
@@ -590,7 +667,7 @@ test "get a direct status" do
     other_user = insert(:user)
 
     {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "@#{other_user.nickname}", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "direct"})
 
     conn =
       conn
@@ -599,7 +676,7 @@ test "get a direct status" do
 
     [participation] = Participation.for_user(user)
 
-    res = json_response(conn, 200)
+    res = json_response_and_validate_schema(conn, 200)
     assert res["pleroma"]["direct_conversation_id"] == participation.id
   end
 
@@ -611,7 +688,8 @@ test "get statuses by IDs" do
     query_string = "ids[]=#{id1}&ids[]=#{id2}"
     conn = get(conn, "/api/v1/statuses/?#{query_string}")
 
-    assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
+    assert [%{"id" => ^id1}, %{"id" => ^id2}] =
+             Enum.sort_by(json_response_and_validate_schema(conn, :ok), & &1["id"])
   end
 
   describe "getting statuses by ids with restricted unauthenticated for local and remote" do
@@ -622,17 +700,17 @@ test "get statuses by IDs" do
     setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
 
     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
-      res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
+      res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
 
-      assert json_response(res_conn, 200) == []
+      assert json_response_and_validate_schema(res_conn, 200) == []
     end
 
     test "if user is authenticated", %{local: local, remote: remote} do
       %{conn: conn} = oauth_access(["read"])
 
-      res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
+      res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
 
-      assert length(json_response(res_conn, 200)) == 2
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
   end
 
@@ -642,18 +720,18 @@ test "if user is authenticated", %{local: local, remote: remote} do
     setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
 
     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
-      res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
+      res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
 
       remote_id = remote.id
-      assert [%{"id" => ^remote_id}] = json_response(res_conn, 200)
+      assert [%{"id" => ^remote_id}] = json_response_and_validate_schema(res_conn, 200)
     end
 
     test "if user is authenticated", %{local: local, remote: remote} do
       %{conn: conn} = oauth_access(["read"])
 
-      res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
+      res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
 
-      assert length(json_response(res_conn, 200)) == 2
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
   end
 
@@ -663,18 +741,18 @@ test "if user is authenticated", %{local: local, remote: remote} do
     setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
 
     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
-      res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
+      res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
 
       local_id = local.id
-      assert [%{"id" => ^local_id}] = json_response(res_conn, 200)
+      assert [%{"id" => ^local_id}] = json_response_and_validate_schema(res_conn, 200)
     end
 
     test "if user is authenticated", %{local: local, remote: remote} do
       %{conn: conn} = oauth_access(["read"])
 
-      res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
+      res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
 
-      assert length(json_response(res_conn, 200)) == 2
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
   end
 
@@ -688,7 +766,7 @@ test "when you created it" do
         |> assign(:user, author)
         |> delete("/api/v1/statuses/#{activity.id}")
 
-      assert %{} = json_response(conn, 200)
+      assert %{} = json_response_and_validate_schema(conn, 200)
 
       refute Activity.get_by_id(activity.id)
     end
@@ -702,7 +780,7 @@ test "when it doesn't exist" do
         |> assign(:user, author)
         |> delete("/api/v1/statuses/#{String.downcase(activity.id)}")
 
-      assert %{"error" => "Record not found"} == json_response(conn, 404)
+      assert %{"error" => "Record not found"} == json_response_and_validate_schema(conn, 404)
     end
 
     test "when you didn't create it" do
@@ -711,7 +789,7 @@ test "when you didn't create it" do
 
       conn = delete(conn, "/api/v1/statuses/#{activity.id}")
 
-      assert %{"error" => _} = json_response(conn, 403)
+      assert %{"error" => _} = json_response_and_validate_schema(conn, 403)
 
       assert Activity.get_by_id(activity.id) == activity
     end
@@ -728,7 +806,7 @@ test "when you're an admin or moderator", %{conn: conn} do
         |> assign(:token, insert(:oauth_token, user: admin, scopes: ["write:statuses"]))
         |> delete("/api/v1/statuses/#{activity1.id}")
 
-      assert %{} = json_response(res_conn, 200)
+      assert %{} = json_response_and_validate_schema(res_conn, 200)
 
       res_conn =
         conn
@@ -736,7 +814,7 @@ test "when you're an admin or moderator", %{conn: conn} do
         |> assign(:token, insert(:oauth_token, user: moderator, scopes: ["write:statuses"]))
         |> delete("/api/v1/statuses/#{activity2.id}")
 
-      assert %{} = json_response(res_conn, 200)
+      assert %{} = json_response_and_validate_schema(res_conn, 200)
 
       refute Activity.get_by_id(activity1.id)
       refute Activity.get_by_id(activity2.id)
@@ -749,12 +827,15 @@ test "when you're an admin or moderator", %{conn: conn} do
     test "reblogs and returns the reblogged status", %{conn: conn} do
       activity = insert(:note_activity)
 
-      conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{activity.id}/reblog")
 
       assert %{
                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
                "reblogged" => true
-             } = json_response(conn, 200)
+             } = json_response_and_validate_schema(conn, 200)
 
       assert to_string(activity.id) == id
     end
@@ -762,21 +843,30 @@ test "reblogs and returns the reblogged status", %{conn: conn} do
     test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
       activity = insert(:note_activity)
 
-      conn = post(conn, "/api/v1/statuses/#{String.downcase(activity.id)}/reblog")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{String.downcase(activity.id)}/reblog")
 
-      assert %{"error" => "Record not found"} = json_response(conn, 404)
+      assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
     end
 
     test "reblogs privately and returns the reblogged status", %{conn: conn} do
       activity = insert(:note_activity)
 
-      conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog", %{"visibility" => "private"})
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post(
+          "/api/v1/statuses/#{activity.id}/reblog",
+          %{"visibility" => "private"}
+        )
 
       assert %{
                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
                "reblogged" => true,
                "visibility" => "private"
-             } = json_response(conn, 200)
+             } = json_response_and_validate_schema(conn, 200)
 
       assert to_string(activity.id) == id
     end
@@ -802,7 +892,7 @@ test "reblogged status for another user" do
                "reblogged" => false,
                "favourited" => false,
                "bookmarked" => false
-             } = json_response(conn_res, 200)
+             } = json_response_and_validate_schema(conn_res, 200)
 
       conn_res =
         build_conn()
@@ -815,7 +905,7 @@ test "reblogged status for another user" do
                "reblogged" => true,
                "favourited" => true,
                "bookmarked" => true
-             } = json_response(conn_res, 200)
+             } = json_response_and_validate_schema(conn_res, 200)
 
       assert to_string(activity.id) == id
     end
@@ -829,17 +919,24 @@ test "unreblogs and returns the unreblogged status", %{user: user, conn: conn} d
 
       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 
-      conn = post(conn, "/api/v1/statuses/#{activity.id}/unreblog")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{activity.id}/unreblog")
 
-      assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
+      assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} =
+               json_response_and_validate_schema(conn, 200)
 
       assert to_string(activity.id) == id
     end
 
     test "returns 404 error when activity does not exist", %{conn: conn} do
-      conn = post(conn, "/api/v1/statuses/foo/unreblog")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/foo/unreblog")
 
-      assert json_response(conn, 404) == %{"error" => "Record not found"}
+      assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
     end
   end
 
@@ -849,10 +946,13 @@ test "returns 404 error when activity does not exist", %{conn: conn} do
     test "favs a status and returns it", %{conn: conn} do
       activity = insert(:note_activity)
 
-      conn = post(conn, "/api/v1/statuses/#{activity.id}/favourite")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{activity.id}/favourite")
 
       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
-               json_response(conn, 200)
+               json_response_and_validate_schema(conn, 200)
 
       assert to_string(activity.id) == id
     end
@@ -860,18 +960,23 @@ test "favs a status and returns it", %{conn: conn} do
     test "favoriting twice will just return 200", %{conn: conn} do
       activity = insert(:note_activity)
 
-      post(conn, "/api/v1/statuses/#{activity.id}/favourite")
+      conn
+      |> put_req_header("content-type", "application/json")
+      |> post("/api/v1/statuses/#{activity.id}/favourite")
 
-      assert post(conn, "/api/v1/statuses/#{activity.id}/favourite")
-             |> json_response(200)
+      assert conn
+             |> put_req_header("content-type", "application/json")
+             |> post("/api/v1/statuses/#{activity.id}/favourite")
+             |> json_response_and_validate_schema(200)
     end
 
     test "returns 404 error for a wrong id", %{conn: conn} do
       conn =
         conn
+        |> put_req_header("content-type", "application/json")
         |> post("/api/v1/statuses/1/favourite")
 
-      assert json_response(conn, 404) == %{"error" => "Record not found"}
+      assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
     end
   end
 
@@ -883,18 +988,24 @@ test "unfavorites a status and returns it", %{user: user, conn: conn} do
 
       {:ok, _} = CommonAPI.favorite(user, activity.id)
 
-      conn = post(conn, "/api/v1/statuses/#{activity.id}/unfavourite")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 
       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
-               json_response(conn, 200)
+               json_response_and_validate_schema(conn, 200)
 
       assert to_string(activity.id) == id
     end
 
     test "returns 404 error for a wrong id", %{conn: conn} do
-      conn = post(conn, "/api/v1/statuses/1/unfavourite")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/1/unfavourite")
 
-      assert json_response(conn, 404) == %{"error" => "Record not found"}
+      assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
     end
   end
 
@@ -902,7 +1013,7 @@ test "returns 404 error for a wrong id", %{conn: conn} do
     setup do: oauth_access(["write:accounts"])
 
     setup %{user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
 
       %{activity: activity}
     end
@@ -914,21 +1025,25 @@ test "pin status", %{conn: conn, user: user, activity: activity} do
 
       assert %{"id" => ^id_str, "pinned" => true} =
                conn
+               |> put_req_header("content-type", "application/json")
                |> post("/api/v1/statuses/#{activity.id}/pin")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
 
       assert [%{"id" => ^id_str, "pinned" => true}] =
                conn
                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
     end
 
     test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
-      {:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
+      {:ok, dm} = CommonAPI.post(user, %{status: "test", visibility: "direct"})
 
-      conn = post(conn, "/api/v1/statuses/#{dm.id}/pin")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{dm.id}/pin")
 
-      assert json_response(conn, 400) == %{"error" => "Could not pin"}
+      assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not pin"}
     end
 
     test "unpin status", %{conn: conn, user: user, activity: activity} do
@@ -941,29 +1056,33 @@ test "unpin status", %{conn: conn, user: user, activity: activity} do
                conn
                |> assign(:user, user)
                |> post("/api/v1/statuses/#{activity.id}/unpin")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
 
       assert [] =
                conn
                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
     end
 
     test "/unpin: returns 400 error when activity is not exist", %{conn: conn} do
-      conn = post(conn, "/api/v1/statuses/1/unpin")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/1/unpin")
 
-      assert json_response(conn, 400) == %{"error" => "Could not unpin"}
+      assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not unpin"}
     end
 
     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
-      {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
+      {:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})
 
       id_str_one = to_string(activity_one.id)
 
       assert %{"id" => ^id_str_one, "pinned" => true} =
                conn
+               |> put_req_header("content-type", "application/json")
                |> post("/api/v1/statuses/#{id_str_one}/pin")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
 
       user = refresh_record(user)
 
@@ -971,7 +1090,7 @@ test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
                conn
                |> assign(:user, user)
                |> post("/api/v1/statuses/#{activity_two.id}/pin")
-               |> json_response(400)
+               |> json_response_and_validate_schema(400)
     end
   end
 
@@ -985,7 +1104,7 @@ test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
     test "returns rich-media card", %{conn: conn, user: user} do
       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp"})
 
       card_data = %{
         "image" => "http://ia.media-imdb.com/images/rock.jpg",
@@ -1011,18 +1130,18 @@ test "returns rich-media card", %{conn: conn, user: user} do
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/card")
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       assert response == card_data
 
       # works with private posts
       {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})
+        CommonAPI.post(user, %{status: "https://example.com/ogp", visibility: "direct"})
 
       response_two =
         conn
         |> get("/api/v1/statuses/#{activity.id}/card")
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       assert response_two == card_data
     end
@@ -1030,13 +1149,12 @@ test "returns rich-media card", %{conn: conn, user: user} do
     test "replaces missing description with an empty string", %{conn: conn, user: user} do
       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 
-      {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp-missing-data"})
 
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/card")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       assert response == %{
                "type" => "link",
@@ -1063,36 +1181,42 @@ test "bookmarks" do
     %{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
     author = insert(:user)
 
-    {:ok, activity1} =
-      CommonAPI.post(author, %{
-        "status" => "heweoo?"
-      })
+    {:ok, activity1} = CommonAPI.post(author, %{status: "heweoo?"})
+    {:ok, activity2} = CommonAPI.post(author, %{status: "heweoo!"})
 
-    {:ok, activity2} =
-      CommonAPI.post(author, %{
-        "status" => "heweoo!"
-      })
+    response1 =
+      conn
+      |> put_req_header("content-type", "application/json")
+      |> post("/api/v1/statuses/#{activity1.id}/bookmark")
 
-    response1 = post(conn, "/api/v1/statuses/#{activity1.id}/bookmark")
+    assert json_response_and_validate_schema(response1, 200)["bookmarked"] == true
 
-    assert json_response(response1, 200)["bookmarked"] == true
+    response2 =
+      conn
+      |> put_req_header("content-type", "application/json")
+      |> post("/api/v1/statuses/#{activity2.id}/bookmark")
 
-    response2 = post(conn, "/api/v1/statuses/#{activity2.id}/bookmark")
-
-    assert json_response(response2, 200)["bookmarked"] == true
+    assert json_response_and_validate_schema(response2, 200)["bookmarked"] == true
 
     bookmarks = get(conn, bookmarks_uri)
 
-    assert [json_response(response2, 200), json_response(response1, 200)] ==
-             json_response(bookmarks, 200)
+    assert [
+             json_response_and_validate_schema(response2, 200),
+             json_response_and_validate_schema(response1, 200)
+           ] ==
+             json_response_and_validate_schema(bookmarks, 200)
 
-    response1 = post(conn, "/api/v1/statuses/#{activity1.id}/unbookmark")
+    response1 =
+      conn
+      |> put_req_header("content-type", "application/json")
+      |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
 
-    assert json_response(response1, 200)["bookmarked"] == false
+    assert json_response_and_validate_schema(response1, 200)["bookmarked"] == false
 
     bookmarks = get(conn, bookmarks_uri)
 
-    assert [json_response(response2, 200)] == json_response(bookmarks, 200)
+    assert [json_response_and_validate_schema(response2, 200)] ==
+             json_response_and_validate_schema(bookmarks, 200)
   end
 
   describe "conversation muting" do
@@ -1100,7 +1224,7 @@ test "bookmarks" do
 
     setup do
       post_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
+      {:ok, activity} = CommonAPI.post(post_user, %{status: "HIE"})
       %{activity: activity}
     end
 
@@ -1109,16 +1233,22 @@ test "mute conversation", %{conn: conn, activity: activity} do
 
       assert %{"id" => ^id_str, "muted" => true} =
                conn
+               |> put_req_header("content-type", "application/json")
                |> post("/api/v1/statuses/#{activity.id}/mute")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
     end
 
     test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
       {:ok, _} = CommonAPI.add_mute(user, activity)
 
-      conn = post(conn, "/api/v1/statuses/#{activity.id}/mute")
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/statuses/#{activity.id}/mute")
 
-      assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
+      assert json_response_and_validate_schema(conn, 400) == %{
+               "error" => "conversation is already muted"
+             }
     end
 
     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
@@ -1130,7 +1260,7 @@ test "unmute conversation", %{conn: conn, user: user, activity: activity} do
                conn
                # |> assign(:user, user)
                |> post("/api/v1/statuses/#{activity.id}/unmute")
-               |> json_response(200)
+               |> json_response_and_validate_schema(200)
     end
   end
 
@@ -1139,16 +1269,17 @@ test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{c
     user2 = insert(:user)
     user3 = insert(:user)
 
-    {:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})
+    {:ok, replied_to} = CommonAPI.post(user1, %{status: "cofe"})
 
     # Reply to status from another user
     conn1 =
       conn
       |> assign(:user, user2)
       |> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
+      |> put_req_header("content-type", "application/json")
       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 
-    assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
+    assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn1, 200)
 
     activity = Activity.get_by_id_with_object(id)
 
@@ -1160,10 +1291,11 @@ test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{c
       conn
       |> assign(:user, user3)
       |> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
+      |> put_req_header("content-type", "application/json")
       |> post("/api/v1/statuses/#{activity.id}/reblog")
 
     assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
-             json_response(conn2, 200)
+             json_response_and_validate_schema(conn2, 200)
 
     assert to_string(activity.id) == id
 
@@ -1186,7 +1318,7 @@ test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{c
     setup do: oauth_access(["read:accounts"])
 
     setup %{user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test"})
 
       %{activity: activity}
     end
@@ -1198,7 +1330,7 @@ test "returns users who have favorited the status", %{conn: conn, activity: acti
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       [%{"id" => id}] = response
 
@@ -1212,7 +1344,7 @@ test "returns empty array when status has not been favorited yet", %{
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       assert Enum.empty?(response)
     end
@@ -1229,7 +1361,7 @@ test "does not return users who have favorited the status but are blocked", %{
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       assert Enum.empty?(response)
     end
@@ -1241,7 +1373,7 @@ test "does not fail on an unauthenticated request", %{activity: activity} do
       response =
         build_conn()
         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       [%{"id" => id}] = response
       assert id == other_user.id
@@ -1252,8 +1384,8 @@ test "requires authentication for private posts", %{user: user} do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "@#{other_user.nickname} wanna get some #cofe together?",
-          "visibility" => "direct"
+          status: "@#{other_user.nickname} wanna get some #cofe together?",
+          visibility: "direct"
         })
 
       {:ok, _} = CommonAPI.favorite(other_user, activity.id)
@@ -1262,7 +1394,7 @@ test "requires authentication for private posts", %{user: user} do
 
       build_conn()
       |> get(favourited_by_url)
-      |> json_response(404)
+      |> json_response_and_validate_schema(404)
 
       conn =
         build_conn()
@@ -1272,12 +1404,12 @@ test "requires authentication for private posts", %{user: user} do
       conn
       |> assign(:token, nil)
       |> get(favourited_by_url)
-      |> json_response(404)
+      |> json_response_and_validate_schema(404)
 
       response =
         conn
         |> get(favourited_by_url)
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       [%{"id" => id}] = response
       assert id == other_user.id
@@ -1288,7 +1420,7 @@ test "requires authentication for private posts", %{user: user} do
     setup do: oauth_access(["read:accounts"])
 
     setup %{user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test"})
 
       %{activity: activity}
     end
@@ -1300,7 +1432,7 @@ test "returns users who have reblogged the status", %{conn: conn, activity: acti
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       [%{"id" => id}] = response
 
@@ -1314,7 +1446,7 @@ test "returns empty array when status has not been reblogged yet", %{
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       assert Enum.empty?(response)
     end
@@ -1331,7 +1463,7 @@ test "does not return users who have reblogged the status but are blocked", %{
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       assert Enum.empty?(response)
     end
@@ -1342,12 +1474,12 @@ test "does not return users who have reblogged the status privately", %{
     } do
       other_user = insert(:user)
 
-      {:ok, _, _} = CommonAPI.repeat(activity.id, other_user, %{"visibility" => "private"})
+      {:ok, _, _} = CommonAPI.repeat(activity.id, other_user, %{visibility: "private"})
 
       response =
         conn
         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       assert Enum.empty?(response)
     end
@@ -1359,7 +1491,7 @@ test "does not fail on an unauthenticated request", %{activity: activity} do
       response =
         build_conn()
         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-        |> json_response(:ok)
+        |> json_response_and_validate_schema(:ok)
 
       [%{"id" => id}] = response
       assert id == other_user.id
@@ -1370,20 +1502,20 @@ test "requires authentication for private posts", %{user: user} do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "status" => "@#{other_user.nickname} wanna get some #cofe together?",
-          "visibility" => "direct"
+          status: "@#{other_user.nickname} wanna get some #cofe together?",
+          visibility: "direct"
         })
 
       build_conn()
       |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-      |> json_response(404)
+      |> json_response_and_validate_schema(404)
 
       response =
         build_conn()
         |> assign(:user, other_user)
         |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       assert [] == response
     end
@@ -1392,16 +1524,16 @@ test "requires authentication for private posts", %{user: user} do
   test "context" do
     user = insert(:user)
 
-    {:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
-    {:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
-    {:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
-    {:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
-    {:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})
+    {:ok, %{id: id1}} = CommonAPI.post(user, %{status: "1"})
+    {:ok, %{id: id2}} = CommonAPI.post(user, %{status: "2", in_reply_to_status_id: id1})
+    {:ok, %{id: id3}} = CommonAPI.post(user, %{status: "3", in_reply_to_status_id: id2})
+    {:ok, %{id: id4}} = CommonAPI.post(user, %{status: "4", in_reply_to_status_id: id3})
+    {:ok, %{id: id5}} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})
 
     response =
       build_conn()
       |> get("/api/v1/statuses/#{id3}/context")
-      |> json_response(:ok)
+      |> json_response_and_validate_schema(:ok)
 
     assert %{
              "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
@@ -1413,14 +1545,14 @@ test "returns the favorites of a user" do
     %{user: user, conn: conn} = oauth_access(["read:favourites"])
     other_user = insert(:user)
 
-    {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
+    {:ok, _} = CommonAPI.post(other_user, %{status: "bla"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "traps are happy"})
 
     {:ok, _} = CommonAPI.favorite(user, activity.id)
 
     first_conn = get(conn, "/api/v1/favourites")
 
-    assert [status] = json_response(first_conn, 200)
+    assert [status] = json_response_and_validate_schema(first_conn, 200)
     assert status["id"] == to_string(activity.id)
 
     assert [{"link", _link_header}] =
@@ -1429,8 +1561,7 @@ test "returns the favorites of a user" do
     # Honours query params
     {:ok, second_activity} =
       CommonAPI.post(other_user, %{
-        "status" =>
-          "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
+        status: "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
       })
 
     {:ok, _} = CommonAPI.favorite(user, second_activity.id)
@@ -1439,17 +1570,17 @@ test "returns the favorites of a user" do
 
     second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like}")
 
-    assert [second_status] = json_response(second_conn, 200)
+    assert [second_status] = json_response_and_validate_schema(second_conn, 200)
     assert second_status["id"] == to_string(second_activity.id)
 
     third_conn = get(conn, "/api/v1/favourites?limit=0")
 
-    assert [] = json_response(third_conn, 200)
+    assert [] = json_response_and_validate_schema(third_conn, 200)
   end
 
   test "expires_at is nil for another user" do
     %{conn: conn, user: user} = oauth_access(["read:statuses"])
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "foobar", "expires_in" => 1_000_000})
+    {:ok, activity} = CommonAPI.post(user, %{status: "foobar", expires_in: 1_000_000})
 
     expires_at =
       activity.id
@@ -1458,11 +1589,15 @@ test "expires_at is nil for another user" do
       |> NaiveDateTime.to_iso8601()
 
     assert %{"pleroma" => %{"expires_at" => ^expires_at}} =
-             conn |> get("/api/v1/statuses/#{activity.id}") |> json_response(:ok)
+             conn
+             |> get("/api/v1/statuses/#{activity.id}")
+             |> json_response_and_validate_schema(:ok)
 
     %{conn: conn} = oauth_access(["read:statuses"])
 
     assert %{"pleroma" => %{"expires_at" => nil}} =
-             conn |> get("/api/v1/statuses/#{activity.id}") |> json_response(:ok)
+             conn
+             |> get("/api/v1/statuses/#{activity.id}")
+             |> json_response_and_validate_schema(:ok)
   end
 end
diff --git a/test/web/mastodon_api/controllers/suggestion_controller_test.exs b/test/web/mastodon_api/controllers/suggestion_controller_test.exs
index f120bd0cd..7f08e187c 100644
--- a/test/web/mastodon_api/controllers/suggestion_controller_test.exs
+++ b/test/web/mastodon_api/controllers/suggestion_controller_test.exs
@@ -11,7 +11,7 @@ test "returns empty result", %{conn: conn} do
     res =
       conn
       |> get("/api/v1/suggestions")
-      |> json_response(200)
+      |> json_response_and_validate_schema(200)
 
     assert res == []
   end
diff --git a/test/web/mastodon_api/controllers/timeline_controller_test.exs b/test/web/mastodon_api/controllers/timeline_controller_test.exs
index a5c227991..237d7daa5 100644
--- a/test/web/mastodon_api/controllers/timeline_controller_test.exs
+++ b/test/web/mastodon_api/controllers/timeline_controller_test.exs
@@ -28,13 +28,13 @@ test "does NOT render account/pleroma/relationship if this is disabled by defaul
 
       other_user = insert(:user)
 
-      {:ok, _} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
+      {:ok, _} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 
       response =
         conn
         |> assign(:user, user)
         |> get("/api/v1/timelines/home")
-        |> json_response(200)
+        |> json_response_and_validate_schema(200)
 
       assert Enum.all?(response, fn n ->
                get_in(n, ["account", "pleroma", "relationship"]) == %{}
@@ -42,13 +42,13 @@ test "does NOT render account/pleroma/relationship if this is disabled by defaul
     end
 
     test "the home timeline", %{user: user, conn: conn} do
-      uri = "/api/v1/timelines/home?with_relationships=true"
+      uri = "/api/v1/timelines/home?with_relationships=1"
 
       following = insert(:user, nickname: "followed")
       third_user = insert(:user, nickname: "repeated")
 
-      {:ok, _activity} = CommonAPI.post(following, %{"status" => "post"})
-      {:ok, activity} = CommonAPI.post(third_user, %{"status" => "repeated post"})
+      {:ok, _activity} = CommonAPI.post(following, %{status: "post"})
+      {:ok, activity} = CommonAPI.post(third_user, %{status: "repeated post"})
       {:ok, _, _} = CommonAPI.repeat(activity.id, following)
 
       # This one should not show up in the TL
@@ -56,7 +56,7 @@ test "the home timeline", %{user: user, conn: conn} do
 
       ret_conn = get(conn, uri)
 
-      assert Enum.empty?(json_response(ret_conn, :ok))
+      assert Enum.empty?(json_response_and_validate_schema(ret_conn, :ok))
 
       {:ok, _user} = User.follow(user, following)
 
@@ -81,7 +81,7 @@ test "the home timeline", %{user: user, conn: conn} do
                    "pleroma" => %{"relationship" => %{"following" => true}}
                  }
                }
-             ] = json_response(ret_conn, :ok)
+             ] = json_response_and_validate_schema(ret_conn, :ok)
 
       {:ok, _user} = User.follow(third_user, user)
 
@@ -107,22 +107,20 @@ test "the home timeline", %{user: user, conn: conn} do
                    "pleroma" => %{"relationship" => %{"following" => true}}
                  }
                }
-             ] = json_response(ret_conn, :ok)
+             ] = json_response_and_validate_schema(ret_conn, :ok)
     end
 
     test "the home timeline when the direct messages are excluded", %{user: user, conn: conn} do
-      {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
-      {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+      {:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
+      {:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
 
-      {:ok, unlisted_activity} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
+      {:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
 
-      {:ok, private_activity} =
-        CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
+      {:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 
-      conn = get(conn, "/api/v1/timelines/home", %{"exclude_visibilities" => ["direct"]})
+      conn = get(conn, "/api/v1/timelines/home?exclude_visibilities[]=direct")
 
-      assert status_ids = json_response(conn, :ok) |> Enum.map(& &1["id"])
+      assert status_ids = json_response_and_validate_schema(conn, :ok) |> Enum.map(& &1["id"])
       assert public_activity.id in status_ids
       assert unlisted_activity.id in status_ids
       assert private_activity.id in status_ids
@@ -135,33 +133,33 @@ test "the home timeline when the direct messages are excluded", %{user: user, co
     test "the public timeline", %{conn: conn} do
       following = insert(:user)
 
-      {:ok, _activity} = CommonAPI.post(following, %{"status" => "test"})
+      {:ok, _activity} = CommonAPI.post(following, %{status: "test"})
 
       _activity = insert(:note_activity, local: false)
 
-      conn = get(conn, "/api/v1/timelines/public", %{"local" => "False"})
+      conn = get(conn, "/api/v1/timelines/public?local=False")
 
-      assert length(json_response(conn, :ok)) == 2
+      assert length(json_response_and_validate_schema(conn, :ok)) == 2
 
-      conn = get(build_conn(), "/api/v1/timelines/public", %{"local" => "True"})
+      conn = get(build_conn(), "/api/v1/timelines/public?local=True")
 
-      assert [%{"content" => "test"}] = json_response(conn, :ok)
+      assert [%{"content" => "test"}] = json_response_and_validate_schema(conn, :ok)
 
-      conn = get(build_conn(), "/api/v1/timelines/public", %{"local" => "1"})
+      conn = get(build_conn(), "/api/v1/timelines/public?local=1")
 
-      assert [%{"content" => "test"}] = json_response(conn, :ok)
+      assert [%{"content" => "test"}] = json_response_and_validate_schema(conn, :ok)
     end
 
     test "the public timeline includes only public statuses for an authenticated user" do
       %{user: user, conn: conn} = oauth_access(["read:statuses"])
 
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "test"})
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "test", "visibility" => "private"})
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "test", "visibility" => "unlisted"})
-      {:ok, _activity} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "test"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "private"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "unlisted"})
+      {:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "direct"})
 
       res_conn = get(conn, "/api/v1/timelines/public")
-      assert length(json_response(res_conn, 200)) == 1
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 1
     end
   end
 
@@ -179,15 +177,15 @@ defp local_and_remote_activities do
     setup do: clear_config([:restrict_unauthenticated, :timelines, :federated], true)
 
     test "if user is unauthenticated", %{conn: conn} do
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "true"})
+      res_conn = get(conn, "/api/v1/timelines/public?local=true")
 
-      assert json_response(res_conn, :unauthorized) == %{
+      assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
                "error" => "authorization required for timeline view"
              }
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "false"})
+      res_conn = get(conn, "/api/v1/timelines/public?local=false")
 
-      assert json_response(res_conn, :unauthorized) == %{
+      assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
                "error" => "authorization required for timeline view"
              }
     end
@@ -195,11 +193,11 @@ test "if user is unauthenticated", %{conn: conn} do
     test "if user is authenticated" do
       %{conn: conn} = oauth_access(["read:statuses"])
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "true"})
-      assert length(json_response(res_conn, 200)) == 1
+      res_conn = get(conn, "/api/v1/timelines/public?local=true")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 1
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "false"})
-      assert length(json_response(res_conn, 200)) == 2
+      res_conn = get(conn, "/api/v1/timelines/public?local=false")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
   end
 
@@ -209,24 +207,24 @@ test "if user is authenticated" do
     setup do: clear_config([:restrict_unauthenticated, :timelines, :local], true)
 
     test "if user is unauthenticated", %{conn: conn} do
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "true"})
+      res_conn = get(conn, "/api/v1/timelines/public?local=true")
 
-      assert json_response(res_conn, :unauthorized) == %{
+      assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
                "error" => "authorization required for timeline view"
              }
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "false"})
-      assert length(json_response(res_conn, 200)) == 2
+      res_conn = get(conn, "/api/v1/timelines/public?local=false")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
 
     test "if user is authenticated", %{conn: _conn} do
       %{conn: conn} = oauth_access(["read:statuses"])
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "true"})
-      assert length(json_response(res_conn, 200)) == 1
+      res_conn = get(conn, "/api/v1/timelines/public?local=true")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 1
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "false"})
-      assert length(json_response(res_conn, 200)) == 2
+      res_conn = get(conn, "/api/v1/timelines/public?local=false")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
   end
 
@@ -236,12 +234,12 @@ test "if user is authenticated", %{conn: _conn} do
     setup do: clear_config([:restrict_unauthenticated, :timelines, :federated], true)
 
     test "if user is unauthenticated", %{conn: conn} do
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "true"})
-      assert length(json_response(res_conn, 200)) == 1
+      res_conn = get(conn, "/api/v1/timelines/public?local=true")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 1
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "false"})
+      res_conn = get(conn, "/api/v1/timelines/public?local=false")
 
-      assert json_response(res_conn, :unauthorized) == %{
+      assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
                "error" => "authorization required for timeline view"
              }
     end
@@ -249,11 +247,11 @@ test "if user is unauthenticated", %{conn: conn} do
     test "if user is authenticated", %{conn: _conn} do
       %{conn: conn} = oauth_access(["read:statuses"])
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "true"})
-      assert length(json_response(res_conn, 200)) == 1
+      res_conn = get(conn, "/api/v1/timelines/public?local=true")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 1
 
-      res_conn = get(conn, "/api/v1/timelines/public", %{"local" => "false"})
-      assert length(json_response(res_conn, 200)) == 2
+      res_conn = get(conn, "/api/v1/timelines/public?local=false")
+      assert length(json_response_and_validate_schema(res_conn, 200)) == 2
     end
   end
 
@@ -266,14 +264,14 @@ test "direct timeline", %{conn: conn} do
 
       {:ok, direct} =
         CommonAPI.post(user_one, %{
-          "status" => "Hi @#{user_two.nickname}!",
-          "visibility" => "direct"
+          status: "Hi @#{user_two.nickname}!",
+          visibility: "direct"
         })
 
       {:ok, _follower_only} =
         CommonAPI.post(user_one, %{
-          "status" => "Hi @#{user_two.nickname}!",
-          "visibility" => "private"
+          status: "Hi @#{user_two.nickname}!",
+          visibility: "private"
         })
 
       conn_user_two =
@@ -284,7 +282,7 @@ test "direct timeline", %{conn: conn} do
       # Only direct should be visible here
       res_conn = get(conn_user_two, "api/v1/timelines/direct")
 
-      [status] = json_response(res_conn, :ok)
+      assert [status] = json_response_and_validate_schema(res_conn, :ok)
 
       assert %{"visibility" => "direct"} = status
       assert status["url"] != direct.data["id"]
@@ -296,33 +294,34 @@ test "direct timeline", %{conn: conn} do
         |> assign(:token, insert(:oauth_token, user: user_one, scopes: ["read:statuses"]))
         |> get("api/v1/timelines/direct")
 
-      [status] = json_response(res_conn, :ok)
+      [status] = json_response_and_validate_schema(res_conn, :ok)
 
       assert %{"visibility" => "direct"} = status
 
       # Both should be visible here
       res_conn = get(conn_user_two, "api/v1/timelines/home")
 
-      [_s1, _s2] = json_response(res_conn, :ok)
+      [_s1, _s2] = json_response_and_validate_schema(res_conn, :ok)
 
       # Test pagination
       Enum.each(1..20, fn _ ->
         {:ok, _} =
           CommonAPI.post(user_one, %{
-            "status" => "Hi @#{user_two.nickname}!",
-            "visibility" => "direct"
+            status: "Hi @#{user_two.nickname}!",
+            visibility: "direct"
           })
       end)
 
       res_conn = get(conn_user_two, "api/v1/timelines/direct")
 
-      statuses = json_response(res_conn, :ok)
+      statuses = json_response_and_validate_schema(res_conn, :ok)
       assert length(statuses) == 20
 
-      res_conn =
-        get(conn_user_two, "api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
+      max_id = List.last(statuses)["id"]
 
-      [status] = json_response(res_conn, :ok)
+      res_conn = get(conn_user_two, "api/v1/timelines/direct?max_id=#{max_id}")
+
+      assert [status] = json_response_and_validate_schema(res_conn, :ok)
 
       assert status["url"] != direct.data["id"]
     end
@@ -335,19 +334,19 @@ test "doesn't include DMs from blocked users" do
 
       {:ok, _blocked_direct} =
         CommonAPI.post(blocked, %{
-          "status" => "Hi @#{blocker.nickname}!",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}!",
+          visibility: "direct"
         })
 
       {:ok, direct} =
         CommonAPI.post(other_user, %{
-          "status" => "Hi @#{blocker.nickname}!",
-          "visibility" => "direct"
+          status: "Hi @#{blocker.nickname}!",
+          visibility: "direct"
         })
 
       res_conn = get(conn, "api/v1/timelines/direct")
 
-      [status] = json_response(res_conn, :ok)
+      [status] = json_response_and_validate_schema(res_conn, :ok)
       assert status["id"] == direct.id
     end
   end
@@ -357,14 +356,14 @@ test "doesn't include DMs from blocked users" do
 
     test "list timeline", %{user: user, conn: conn} do
       other_user = insert(:user)
-      {:ok, _activity_one} = CommonAPI.post(user, %{"status" => "Marisa is cute."})
-      {:ok, activity_two} = CommonAPI.post(other_user, %{"status" => "Marisa is cute."})
+      {:ok, _activity_one} = CommonAPI.post(user, %{status: "Marisa is cute."})
+      {:ok, activity_two} = CommonAPI.post(other_user, %{status: "Marisa is cute."})
       {:ok, list} = Pleroma.List.create("name", user)
       {:ok, list} = Pleroma.List.follow(list, other_user)
 
       conn = get(conn, "/api/v1/timelines/list/#{list.id}")
 
-      assert [%{"id" => id}] = json_response(conn, :ok)
+      assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)
 
       assert id == to_string(activity_two.id)
     end
@@ -374,12 +373,12 @@ test "list timeline does not leak non-public statuses for unfollowed users", %{
       conn: conn
     } do
       other_user = insert(:user)
-      {:ok, activity_one} = CommonAPI.post(other_user, %{"status" => "Marisa is cute."})
+      {:ok, activity_one} = CommonAPI.post(other_user, %{status: "Marisa is cute."})
 
       {:ok, _activity_two} =
         CommonAPI.post(other_user, %{
-          "status" => "Marisa is cute.",
-          "visibility" => "private"
+          status: "Marisa is cute.",
+          visibility: "private"
         })
 
       {:ok, list} = Pleroma.List.create("name", user)
@@ -387,7 +386,7 @@ test "list timeline does not leak non-public statuses for unfollowed users", %{
 
       conn = get(conn, "/api/v1/timelines/list/#{list.id}")
 
-      assert [%{"id" => id}] = json_response(conn, :ok)
+      assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)
 
       assert id == to_string(activity_one.id)
     end
@@ -400,18 +399,18 @@ test "list timeline does not leak non-public statuses for unfollowed users", %{
     test "hashtag timeline", %{conn: conn} do
       following = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(following, %{"status" => "test #2hu"})
+      {:ok, activity} = CommonAPI.post(following, %{status: "test #2hu"})
 
       nconn = get(conn, "/api/v1/timelines/tag/2hu")
 
-      assert [%{"id" => id}] = json_response(nconn, :ok)
+      assert [%{"id" => id}] = json_response_and_validate_schema(nconn, :ok)
 
       assert id == to_string(activity.id)
 
       # works for different capitalization too
       nconn = get(conn, "/api/v1/timelines/tag/2HU")
 
-      assert [%{"id" => id}] = json_response(nconn, :ok)
+      assert [%{"id" => id}] = json_response_and_validate_schema(nconn, :ok)
 
       assert id == to_string(activity.id)
     end
@@ -419,26 +418,25 @@ test "hashtag timeline", %{conn: conn} do
     test "multi-hashtag timeline", %{conn: conn} do
       user = insert(:user)
 
-      {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
-      {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
-      {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
+      {:ok, activity_test} = CommonAPI.post(user, %{status: "#test"})
+      {:ok, activity_test1} = CommonAPI.post(user, %{status: "#test #test1"})
+      {:ok, activity_none} = CommonAPI.post(user, %{status: "#test #none"})
 
-      any_test = get(conn, "/api/v1/timelines/tag/test", %{"any" => ["test1"]})
+      any_test = get(conn, "/api/v1/timelines/tag/test?any[]=test1")
 
-      [status_none, status_test1, status_test] = json_response(any_test, :ok)
+      [status_none, status_test1, status_test] = json_response_and_validate_schema(any_test, :ok)
 
       assert to_string(activity_test.id) == status_test["id"]
       assert to_string(activity_test1.id) == status_test1["id"]
       assert to_string(activity_none.id) == status_none["id"]
 
-      restricted_test =
-        get(conn, "/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
+      restricted_test = get(conn, "/api/v1/timelines/tag/test?all[]=test1&none[]=none")
 
-      assert [status_test1] == json_response(restricted_test, :ok)
+      assert [status_test1] == json_response_and_validate_schema(restricted_test, :ok)
 
-      all_test = get(conn, "/api/v1/timelines/tag/test", %{"all" => ["none"]})
+      all_test = get(conn, "/api/v1/timelines/tag/test?all[]=none")
 
-      assert [status_none] == json_response(all_test, :ok)
+      assert [status_none] == json_response_and_validate_schema(all_test, :ok)
     end
   end
 end
diff --git a/test/web/mastodon_api/mastodon_api_test.exs b/test/web/mastodon_api/mastodon_api_test.exs
index cb971806a..a7f9c5205 100644
--- a/test/web/mastodon_api/mastodon_api_test.exs
+++ b/test/web/mastodon_api/mastodon_api_test.exs
@@ -75,9 +75,9 @@ test "returns notifications for user" do
 
       User.subscribe(subscriber, user)
 
-      {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
+      {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
 
-      {:ok, status1} = CommonAPI.post(user, %{"status" => "Magi"})
+      {:ok, status1} = CommonAPI.post(user, %{status: "Magi"})
       {:ok, [notification]} = Notification.create_notifications(status)
       {:ok, [notification1]} = Notification.create_notifications(status1)
       res = MastodonAPI.get_notifications(subscriber)
diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
index ea21f2ce0..035b1f6ac 100644
--- a/test/web/mastodon_api/views/account_view_test.exs
+++ b/test/web/mastodon_api/views/account_view_test.exs
@@ -94,7 +94,14 @@ test "Represent a user account" do
   test "Represent the user account for the account owner" do
     user = insert(:user)
 
-    notification_settings = %Pleroma.User.NotificationSetting{}
+    notification_settings = %{
+      followers: true,
+      follows: true,
+      non_followers: true,
+      non_follows: true,
+      privacy_option: false
+    }
+
     privacy = user.default_scope
 
     assert %{
@@ -455,8 +462,8 @@ test "shows unread_conversation_count only to the account owner" do
 
       {:ok, _activity} =
         CommonAPI.post(other_user, %{
-          "status" => "Hey @#{user.nickname}.",
-          "visibility" => "direct"
+          status: "Hey @#{user.nickname}.",
+          visibility: "direct"
         })
 
       user = User.get_cached_by_ap_id(user.ap_id)
diff --git a/test/web/mastodon_api/views/conversation_view_test.exs b/test/web/mastodon_api/views/conversation_view_test.exs
index dbf3c51e2..6f84366f8 100644
--- a/test/web/mastodon_api/views/conversation_view_test.exs
+++ b/test/web/mastodon_api/views/conversation_view_test.exs
@@ -16,7 +16,7 @@ test "represents a Mastodon Conversation entity" do
     other_user = insert(:user)
 
     {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "hey @#{other_user.nickname}", visibility: "direct"})
 
     [participation] = Participation.for_user_with_last_activity_id(user)
 
diff --git a/test/web/mastodon_api/views/notification_view_test.exs b/test/web/mastodon_api/views/notification_view_test.exs
index 2416772bb..f3d269daf 100644
--- a/test/web/mastodon_api/views/notification_view_test.exs
+++ b/test/web/mastodon_api/views/notification_view_test.exs
@@ -60,7 +60,7 @@ test "ChatMessage notification" do
   test "Mention notification" do
     user = insert(:user)
     mentioned_user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{mentioned_user.nickname}"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
     {:ok, [notification]} = Notification.create_notifications(activity)
     user = User.get_cached_by_id(user.id)
 
@@ -79,7 +79,7 @@ test "Mention notification" do
   test "Favourite notification" do
     user = insert(:user)
     another_user = insert(:user)
-    {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
+    {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
     {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
     {:ok, [notification]} = Notification.create_notifications(favorite_activity)
     create_activity = Activity.get_by_id(create_activity.id)
@@ -99,7 +99,7 @@ test "Favourite notification" do
   test "Reblog notification" do
     user = insert(:user)
     another_user = insert(:user)
-    {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
+    {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
     {:ok, reblog_activity, _object} = CommonAPI.repeat(create_activity.id, another_user)
     {:ok, [notification]} = Notification.create_notifications(reblog_activity)
     reblog_activity = Activity.get_by_id(create_activity.id)
@@ -181,7 +181,7 @@ test "EmojiReact notification" do
     user = insert(:user)
     other_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
     {:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 
     activity = Repo.get(Activity, activity.id)
diff --git a/test/web/mastodon_api/views/poll_view_test.exs b/test/web/mastodon_api/views/poll_view_test.exs
index 63b204387..76672f36c 100644
--- a/test/web/mastodon_api/views/poll_view_test.exs
+++ b/test/web/mastodon_api/views/poll_view_test.exs
@@ -22,10 +22,10 @@ test "renders a poll" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "Is Tenshi eating a corndog cute?",
-        "poll" => %{
-          "options" => ["absolutely!", "sure", "yes", "why are you even asking?"],
-          "expires_in" => 20
+        status: "Is Tenshi eating a corndog cute?",
+        poll: %{
+          options: ["absolutely!", "sure", "yes", "why are you even asking?"],
+          expires_in: 20
         }
       })
 
@@ -62,11 +62,11 @@ test "detects if it is multiple choice" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "Which Mastodon developer is your favourite?",
-        "poll" => %{
-          "options" => ["Gargron", "Eugen"],
-          "expires_in" => 20,
-          "multiple" => true
+        status: "Which Mastodon developer is your favourite?",
+        poll: %{
+          options: ["Gargron", "Eugen"],
+          expires_in: 20,
+          multiple: true
         }
       })
 
@@ -91,10 +91,10 @@ test "detects emoji" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "What's with the smug face?",
-        "poll" => %{
-          "options" => [":blank: sip", ":blank::blank: sip", ":blank::blank::blank: sip"],
-          "expires_in" => 20
+        status: "What's with the smug face?",
+        poll: %{
+          options: [":blank: sip", ":blank::blank: sip", ":blank::blank::blank: sip"],
+          expires_in: 20
         }
       })
 
@@ -109,11 +109,11 @@ test "detects vote status" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "Which input devices do you use?",
-        "poll" => %{
-          "options" => ["mouse", "trackball", "trackpoint"],
-          "multiple" => true,
-          "expires_in" => 20
+        status: "Which input devices do you use?",
+        poll: %{
+          options: ["mouse", "trackball", "trackpoint"],
+          multiple: true,
+          expires_in: 20
         }
       })
 
diff --git a/test/web/mastodon_api/views/scheduled_activity_view_test.exs b/test/web/mastodon_api/views/scheduled_activity_view_test.exs
index 0c0987593..fbfd873ef 100644
--- a/test/web/mastodon_api/views/scheduled_activity_view_test.exs
+++ b/test/web/mastodon_api/views/scheduled_activity_view_test.exs
@@ -14,7 +14,7 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityViewTest do
 
   test "A scheduled activity with a media attachment" do
     user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hi"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hi"})
 
     scheduled_at =
       NaiveDateTime.utc_now()
@@ -47,7 +47,7 @@ test "A scheduled activity with a media attachment" do
     expected = %{
       id: to_string(scheduled_activity.id),
       media_attachments:
-        %{"media_ids" => [upload.id]}
+        %{media_ids: [upload.id]}
         |> Utils.attachments_from_ids()
         |> Enum.map(&StatusView.render("attachment.json", %{attachment: &1})),
       params: %{
diff --git a/test/web/mastodon_api/views/status_view_test.exs b/test/web/mastodon_api/views/status_view_test.exs
index b5e7dc317..ffad65b01 100644
--- a/test/web/mastodon_api/views/status_view_test.exs
+++ b/test/web/mastodon_api/views/status_view_test.exs
@@ -20,6 +20,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
 
   import Pleroma.Factory
   import Tesla.Mock
+  import OpenApiSpex.TestAssertions
 
   setup do
     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
@@ -30,7 +31,7 @@ test "has an emoji reaction list" do
     user = insert(:user)
     other_user = insert(:user)
     third_user = insert(:user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "dae cofe??"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})
 
     {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
     {:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
@@ -38,6 +39,8 @@ test "has an emoji reaction list" do
     activity = Repo.get(Activity, activity.id)
     status = StatusView.render("show.json", activity: activity)
 
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
+
     assert status[:pleroma][:emoji_reactions] == [
              %{name: "☕", count: 2, me: false},
              %{name: "🍵", count: 1, me: false}
@@ -45,6 +48,8 @@ test "has an emoji reaction list" do
 
     status = StatusView.render("show.json", activity: activity, for: user)
 
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
+
     assert status[:pleroma][:emoji_reactions] == [
              %{name: "☕", count: 2, me: true},
              %{name: "🍵", count: 1, me: false}
@@ -54,7 +59,7 @@ test "has an emoji reaction list" do
   test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
     [participation] = Participation.for_user(user)
 
     status =
@@ -68,12 +73,13 @@ test "loads and returns the direct conversation id when given the `with_direct_c
 
     status = StatusView.render("show.json", activity: activity, for: user)
     assert status[:pleroma][:direct_conversation_id] == nil
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "returns the direct conversation id when given the `direct_conversation_id` option" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
     [participation] = Participation.for_user(user)
 
     status =
@@ -84,12 +90,13 @@ test "returns the direct conversation id when given the `direct_conversation_id`
       )
 
     assert status[:pleroma][:direct_conversation_id] == participation.id
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "returns a temporary ap_id based user for activities missing db users" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 
     Repo.delete(user)
     Cachex.clear(:user_cache)
@@ -119,7 +126,7 @@ test "returns a temporary ap_id based user for activities missing db users" do
   test "tries to get a user by nickname if fetching by ap_id doesn't work" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 
     {:ok, user} =
       user
@@ -131,6 +138,7 @@ test "tries to get a user by nickname if fetching by ap_id doesn't work" do
     result = StatusView.render("show.json", activity: activity)
 
     assert result[:account][:id] == to_string(user.id)
+    assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "a note with null content" do
@@ -149,6 +157,7 @@ test "a note with null content" do
     status = StatusView.render("show.json", %{activity: note})
 
     assert status.content == ""
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "a note activity" do
@@ -222,6 +231,7 @@ test "a note activity" do
     }
 
     assert status == expected
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "tells if the message is muted for some reason" do
@@ -230,13 +240,14 @@ test "tells if the message is muted for some reason" do
 
     {:ok, _user_relationships} = User.mute(user, other_user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
 
     relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
 
     opts = %{activity: activity}
     status = StatusView.render("show.json", opts)
     assert status.muted == false
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 
     status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
     assert status.muted == false
@@ -247,6 +258,7 @@ test "tells if the message is muted for some reason" do
 
     status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
     assert status.muted == true
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "tells if the message is thread muted" do
@@ -255,7 +267,7 @@ test "tells if the message is thread muted" do
 
     {:ok, _user_relationships} = User.mute(user, other_user)
 
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
     status = StatusView.render("show.json", %{activity: activity, for: user})
 
     assert status.pleroma.thread_muted == false
@@ -270,7 +282,7 @@ test "tells if the message is thread muted" do
   test "tells if the status is bookmarked" do
     user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Cute girls doing cute things"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
     status = StatusView.render("show.json", %{activity: activity})
 
     assert status.bookmarked == false
@@ -292,8 +304,7 @@ test "a reply" do
     note = insert(:note_activity)
     user = insert(:user)
 
-    {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})
+    {:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})
 
     status = StatusView.render("show.json", %{activity: activity})
 
@@ -308,12 +319,14 @@ test "contains mentions" do
     user = insert(:user)
     mentioned = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "hi @#{mentioned.nickname}"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})
 
     status = StatusView.render("show.json", %{activity: activity})
 
     assert status.mentions ==
              Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)
+
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "create mentions from the 'to' field" do
@@ -405,14 +418,14 @@ test "attachments" do
     api_spec = Pleroma.Web.ApiSpec.spec()
 
     assert expected == StatusView.render("attachment.json", %{attachment: object})
-    OpenApiSpex.TestAssertions.assert_schema(expected, "Attachment", api_spec)
+    assert_schema(expected, "Attachment", api_spec)
 
     # If theres a "id", use that instead of the generated one
     object = Map.put(object, "id", 2)
     result = StatusView.render("attachment.json", %{attachment: object})
 
     assert %{id: "2"} = result
-    OpenApiSpex.TestAssertions.assert_schema(result, "Attachment", api_spec)
+    assert_schema(result, "Attachment", api_spec)
   end
 
   test "put the url advertised in the Activity in to the url attribute" do
@@ -436,6 +449,7 @@ test "a reblog" do
     assert represented[:id] == to_string(reblog.id)
     assert represented[:reblog][:id] == to_string(activity.id)
     assert represented[:emojis] == []
+    assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "a peertube video" do
@@ -452,6 +466,7 @@ test "a peertube video" do
 
     assert represented[:id] == to_string(activity.id)
     assert length(represented[:media_attachments]) == 1
+    assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "funkwhale audio" do
@@ -567,13 +582,15 @@ test "embeds a relationship in the account" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "drink more water"
+        status: "drink more water"
       })
 
     result = StatusView.render("show.json", %{activity: activity, for: other_user})
 
     assert result[:account][:pleroma][:relationship] ==
              AccountView.render("relationship.json", %{user: other_user, target: user})
+
+    assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "embeds a relationship in the account in reposts" do
@@ -582,7 +599,7 @@ test "embeds a relationship in the account in reposts" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "˙˙ɐʎns"
+        status: "˙˙ɐʎns"
       })
 
     {:ok, activity, _object} = CommonAPI.repeat(activity.id, other_user)
@@ -594,6 +611,8 @@ test "embeds a relationship in the account in reposts" do
 
     assert result[:reblog][:account][:pleroma][:relationship] ==
              AccountView.render("relationship.json", %{user: user, target: user})
+
+    assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
   end
 
   test "visibility/list" do
@@ -601,8 +620,7 @@ test "visibility/list" do
 
     {:ok, list} = Pleroma.List.create("foo", user)
 
-    {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
 
     status = StatusView.render("show.json", activity: activity)
 
@@ -616,5 +634,6 @@ test "successfully renders a Listen activity (pleroma extension)" do
 
     assert status.length == listen_activity.data["object"]["length"]
     assert status.title == listen_activity.data["object"]["title"]
+    assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
   end
 end
diff --git a/test/web/metadata/twitter_card_test.exs b/test/web/metadata/twitter_card_test.exs
index 9e9c6853a..10931b5ba 100644
--- a/test/web/metadata/twitter_card_test.exs
+++ b/test/web/metadata/twitter_card_test.exs
@@ -30,7 +30,7 @@ test "it renders twitter card for user info" do
 
   test "it uses summary twittercard if post has no attachment" do
     user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "HI"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
 
     note =
       insert(:note, %{
@@ -56,7 +56,7 @@ test "it uses summary twittercard if post has no attachment" do
   test "it renders avatar not attachment if post is nsfw and unfurl_nsfw is disabled" do
     Pleroma.Config.put([Pleroma.Web.Metadata, :unfurl_nsfw], false)
     user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "HI"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
 
     note =
       insert(:note, %{
@@ -100,7 +100,7 @@ test "it renders avatar not attachment if post is nsfw and unfurl_nsfw is disabl
 
   test "it renders supported types of attachments and skips unknown types" do
     user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "HI"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
 
     note =
       insert(:note, %{
diff --git a/test/web/mongooseim/mongoose_im_controller_test.exs b/test/web/mongooseim/mongoose_im_controller_test.exs
index 1ac2f2c27..5176cde84 100644
--- a/test/web/mongooseim/mongoose_im_controller_test.exs
+++ b/test/web/mongooseim/mongoose_im_controller_test.exs
@@ -41,13 +41,13 @@ test "/user_exists", %{conn: conn} do
   end
 
   test "/check_password", %{conn: conn} do
-    user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt("cool"))
+    user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("cool"))
 
     _deactivated_user =
       insert(:user,
         nickname: "konata",
         deactivated: true,
-        password_hash: Comeonin.Pbkdf2.hashpwsalt("cool")
+        password_hash: Pbkdf2.hash_pwd_salt("cool")
       )
 
     res =
diff --git a/test/web/oauth/ldap_authorization_test.exs b/test/web/oauth/ldap_authorization_test.exs
index a8fe8a841..011642c08 100644
--- a/test/web/oauth/ldap_authorization_test.exs
+++ b/test/web/oauth/ldap_authorization_test.exs
@@ -19,7 +19,7 @@ defmodule Pleroma.Web.OAuth.LDAPAuthorizationTest do
   @tag @skip
   test "authorizes the existing user using LDAP credentials" do
     password = "testpassword"
-    user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
+    user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
     app = insert(:oauth_app, scopes: ["read", "write"])
 
     host = Pleroma.Config.get([:ldap, :host]) |> to_charlist
@@ -104,7 +104,7 @@ test "creates a new user after successful LDAP authorization" do
   @tag @skip
   test "falls back to the default authorization when LDAP is unavailable" do
     password = "testpassword"
-    user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
+    user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
     app = insert(:oauth_app, scopes: ["read", "write"])
 
     host = Pleroma.Config.get([:ldap, :host]) |> to_charlist
@@ -148,7 +148,7 @@ test "falls back to the default authorization when LDAP is unavailable" do
   @tag @skip
   test "disallow authorization for wrong LDAP credentials" do
     password = "testpassword"
-    user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
+    user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
     app = insert(:oauth_app, scopes: ["read", "write"])
 
     host = Pleroma.Config.get([:ldap, :host]) |> to_charlist
diff --git a/test/web/oauth/mfa_controller_test.exs b/test/web/oauth/mfa_controller_test.exs
index ce4a07320..3c341facd 100644
--- a/test/web/oauth/mfa_controller_test.exs
+++ b/test/web/oauth/mfa_controller_test.exs
@@ -20,7 +20,7 @@ defmodule Pleroma.Web.OAuth.MFAControllerTest do
       insert(:user,
         multi_factor_authentication_settings: %MFA.Settings{
           enabled: true,
-          backup_codes: [Comeonin.Pbkdf2.hashpwsalt("test-code")],
+          backup_codes: [Pbkdf2.hash_pwd_salt("test-code")],
           totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
         }
       )
@@ -247,7 +247,7 @@ test "returns access token with valid code", %{conn: conn, app: app} do
 
       hashed_codes =
         backup_codes
-        |> Enum.map(&Comeonin.Pbkdf2.hashpwsalt(&1))
+        |> Enum.map(&Pbkdf2.hash_pwd_salt(&1))
 
       user =
         insert(:user,
diff --git a/test/web/oauth/oauth_controller_test.exs b/test/web/oauth/oauth_controller_test.exs
index 7a107584d..d389e4ce0 100644
--- a/test/web/oauth/oauth_controller_test.exs
+++ b/test/web/oauth/oauth_controller_test.exs
@@ -311,7 +311,7 @@ test "with valid params, POST /oauth/register?op=connect redirects to `redirect_
            app: app,
            conn: conn
          } do
-      user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt("testpassword"))
+      user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("testpassword"))
       registration = insert(:registration, user: nil)
       redirect_uri = OAuthController.default_redirect_uri(app)
 
@@ -342,7 +342,7 @@ test "with unlisted `redirect_uri`, POST /oauth/register?op=connect results in H
            app: app,
            conn: conn
          } do
-      user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt("testpassword"))
+      user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("testpassword"))
       registration = insert(:registration, user: nil)
       unlisted_redirect_uri = "http://cross-site-request.com"
 
@@ -750,7 +750,7 @@ test "issues a token for an all-body request" do
 
     test "issues a token for `password` grant_type with valid credentials, with full permissions by default" do
       password = "testpassword"
-      user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
+      user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
 
       app = insert(:oauth_app, scopes: ["read", "write"])
 
@@ -778,7 +778,7 @@ test "issues a mfa token for `password` grant_type, when MFA enabled" do
 
       user =
         insert(:user,
-          password_hash: Comeonin.Pbkdf2.hashpwsalt(password),
+          password_hash: Pbkdf2.hash_pwd_salt(password),
           multi_factor_authentication_settings: %MFA.Settings{
             enabled: true,
             totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
@@ -887,7 +887,7 @@ test "rejects token exchange for valid credentials belonging to unconfirmed user
       password = "testpassword"
 
       {:ok, user} =
-        insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
+        insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
         |> User.confirmation_changeset(need_confirmation: true)
         |> User.update_and_set_cache()
 
@@ -915,7 +915,7 @@ test "rejects token exchange for valid credentials belonging to deactivated user
 
       user =
         insert(:user,
-          password_hash: Comeonin.Pbkdf2.hashpwsalt(password),
+          password_hash: Pbkdf2.hash_pwd_salt(password),
           deactivated: true
         )
 
@@ -943,7 +943,7 @@ test "rejects token exchange for user with password_reset_pending set to true" d
 
       user =
         insert(:user,
-          password_hash: Comeonin.Pbkdf2.hashpwsalt(password),
+          password_hash: Pbkdf2.hash_pwd_salt(password),
           password_reset_pending: true
         )
 
@@ -972,7 +972,7 @@ test "rejects token exchange for user with confirmation_pending set to true" do
 
       user =
         insert(:user,
-          password_hash: Comeonin.Pbkdf2.hashpwsalt(password),
+          password_hash: Pbkdf2.hash_pwd_salt(password),
           confirmation_pending: true
         )
 
diff --git a/test/web/pleroma_api/controllers/account_controller_test.exs b/test/web/pleroma_api/controllers/account_controller_test.exs
index 6b671a667..34fc4aa23 100644
--- a/test/web/pleroma_api/controllers/account_controller_test.exs
+++ b/test/web/pleroma_api/controllers/account_controller_test.exs
@@ -171,8 +171,8 @@ test "returns favorited DM only when user is logged in and he is one of recipien
     } do
       {:ok, direct} =
         CommonAPI.post(current_user, %{
-          "status" => "Hi @#{user.nickname}!",
-          "visibility" => "direct"
+          status: "Hi @#{user.nickname}!",
+          visibility: "direct"
         })
 
       CommonAPI.favorite(user, direct.id)
@@ -204,8 +204,8 @@ test "does not return others' favorited DM when user is not one of recipients",
 
       {:ok, direct} =
         CommonAPI.post(user_two, %{
-          "status" => "Hi @#{user.nickname}!",
-          "visibility" => "direct"
+          status: "Hi @#{user.nickname}!",
+          visibility: "direct"
         })
 
       CommonAPI.favorite(user, direct.id)
diff --git a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs b/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
index 43f1b154d..cfd1dbd24 100644
--- a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
+++ b/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
@@ -20,7 +20,7 @@ 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"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
 
     result =
       conn
@@ -42,7 +42,7 @@ 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, activity} = CommonAPI.post(user, %{status: "#cofe"})
     {:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 
     ObanHelpers.perform_all()
@@ -68,7 +68,7 @@ test "GET /api/v1/pleroma/statuses/:id/reactions", %{conn: conn} do
     other_user = insert(:user)
     doomed_user = insert(:user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
 
     result =
       conn
@@ -106,7 +106,7 @@ 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"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
 
     result =
       conn
@@ -133,7 +133,7 @@ test "/api/v1/pleroma/conversations/:id" do
     %{user: other_user, conn: conn} = oauth_access(["read:statuses"])
 
     {:ok, _activity} =
-      CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}!", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
 
     [participation] = Participation.for_user(other_user)
 
@@ -151,18 +151,18 @@ test "/api/v1/pleroma/conversations/:id/statuses" do
     third_user = insert(:user)
 
     {:ok, _activity} =
-      CommonAPI.post(user, %{"status" => "Hi @#{third_user.nickname}!", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hi @#{third_user.nickname}!", visibility: "direct"})
 
     {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}!", "visibility" => "direct"})
+      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
+        status: "Hi!",
+        in_reply_to_status_id: activity.id,
+        in_reply_to_conversation_id: participation.id
       })
 
     result =
@@ -178,9 +178,9 @@ test "/api/v1/pleroma/conversations/:id/statuses" do
 
     {:ok, %{id: id_three}} =
       CommonAPI.post(other_user, %{
-        "status" => "Bye!",
-        "in_reply_to_status_id" => activity.id,
-        "in_reply_to_conversation_id" => participation.id
+        status: "Bye!",
+        in_reply_to_status_id: activity.id,
+        in_reply_to_conversation_id: participation.id
       })
 
     assert [%{"id" => ^id_two}, %{"id" => ^id_three}] =
@@ -198,7 +198,7 @@ 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"})
+    {:ok, _activity} = CommonAPI.post(user, %{status: "Hi", visibility: "direct"})
 
     [participation] = Participation.for_user(user)
 
@@ -229,10 +229,10 @@ test "POST /api/v1/pleroma/conversations/read" do
     %{user: other_user, conn: conn} = oauth_access(["write:conversations"])
 
     {:ok, _activity} =
-      CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
 
     {:ok, _activity} =
-      CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}", "visibility" => "direct"})
+      CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
 
     [participation2, participation1] = Participation.for_user(other_user)
     assert Participation.get(participation2.id).read == false
@@ -255,8 +255,8 @@ test "POST /api/v1/pleroma/conversations/read" do
 
     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, 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)
 
@@ -272,9 +272,9 @@ test "it marks a single notification as read", %{user: user1, conn: conn} do
 
     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}"})
+      {: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})
 
diff --git a/test/web/push/impl_test.exs b/test/web/push/impl_test.exs
index b855d72ba..2fc3e73b5 100644
--- a/test/web/push/impl_test.exs
+++ b/test/web/push/impl_test.exs
@@ -55,7 +55,7 @@ test "performs sending notifications" do
       data: %{alerts: %{"follow" => true, "mention" => false}}
     )
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "<Lorem ipsum dolor sit amet."})
+    {:ok, activity} = CommonAPI.post(user, %{status: "<Lorem ipsum dolor sit amet."})
 
     notif =
       insert(:notification,
@@ -111,7 +111,7 @@ test "renders title and body for create activity" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" =>
+        status:
           "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
       })
 
@@ -147,7 +147,7 @@ test "renders title and body for announce activity" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" =>
+        status:
           "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
       })
 
@@ -166,7 +166,7 @@ test "renders title and body for like activity" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" =>
+        status:
           "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
       })
 
@@ -184,8 +184,8 @@ test "renders title for create activity with direct visibility" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "visibility" => "direct",
-        "status" => "This is just between you and me, pal"
+        visibility: "direct",
+        status: "This is just between you and me, pal"
       })
 
     assert Impl.format_title(%{activity: activity}) ==
@@ -199,8 +199,8 @@ test "hides details for notifications when privacy option enabled" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "visibility" => "direct",
-          "status" => "<Lorem ipsum dolor sit amet."
+          visibility: "direct",
+          status: "<Lorem ipsum dolor sit amet."
         })
 
       notif = insert(:notification, user: user2, activity: activity)
@@ -214,8 +214,8 @@ test "hides details for notifications when privacy option enabled" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "visibility" => "public",
-          "status" => "<Lorem ipsum dolor sit amet."
+          visibility: "public",
+          status: "<Lorem ipsum dolor sit amet."
         })
 
       notif = insert(:notification, user: user2, activity: activity)
@@ -245,8 +245,8 @@ test "returns regular content for notifications with privacy option disabled" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "visibility" => "direct",
-          "status" =>
+          visibility: "direct",
+          status:
             "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
         })
 
@@ -263,8 +263,8 @@ test "returns regular content for notifications with privacy option disabled" do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
-          "visibility" => "public",
-          "status" =>
+          visibility: "public",
+          status:
             "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
         })
 
diff --git a/test/web/rich_media/helpers_test.exs b/test/web/rich_media/helpers_test.exs
index aa0c5c830..8264a9c41 100644
--- a/test/web/rich_media/helpers_test.exs
+++ b/test/web/rich_media/helpers_test.exs
@@ -26,8 +26,8 @@ test "refuses to crawl incomplete URLs" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "[test](example.com/ogp)",
-        "content_type" => "text/markdown"
+        status: "[test](example.com/ogp)",
+        content_type: "text/markdown"
       })
 
     Config.put([:rich_media, :enabled], true)
@@ -40,8 +40,8 @@ test "refuses to crawl malformed URLs" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "[test](example.com[]/ogp)",
-        "content_type" => "text/markdown"
+        status: "[test](example.com[]/ogp)",
+        content_type: "text/markdown"
       })
 
     Config.put([:rich_media, :enabled], true)
@@ -54,8 +54,8 @@ test "crawls valid, complete URLs" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "[test](https://example.com/ogp)",
-        "content_type" => "text/markdown"
+        status: "[test](https://example.com/ogp)",
+        content_type: "text/markdown"
       })
 
     Config.put([:rich_media, :enabled], true)
@@ -69,8 +69,8 @@ test "refuses to crawl URLs from posts marked sensitive" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "http://example.com/ogp",
-        "sensitive" => true
+        status: "http://example.com/ogp",
+        sensitive: true
       })
 
     %Object{} = object = Object.normalize(activity)
@@ -87,7 +87,7 @@ test "refuses to crawl URLs from posts tagged NSFW" do
 
     {:ok, activity} =
       CommonAPI.post(user, %{
-        "status" => "http://example.com/ogp #nsfw"
+        status: "http://example.com/ogp #nsfw"
       })
 
     %Object{} = object = Object.normalize(activity)
@@ -103,12 +103,12 @@ test "refuses to crawl URLs of private network from posts" do
     user = insert(:user)
 
     {:ok, activity} =
-      CommonAPI.post(user, %{"status" => "http://127.0.0.1:4000/notice/9kCP7VNyPJXFOXDrgO"})
+      CommonAPI.post(user, %{status: "http://127.0.0.1:4000/notice/9kCP7VNyPJXFOXDrgO"})
 
-    {:ok, activity2} = CommonAPI.post(user, %{"status" => "https://10.111.10.1/notice/9kCP7V"})
-    {:ok, activity3} = CommonAPI.post(user, %{"status" => "https://172.16.32.40/notice/9kCP7V"})
-    {:ok, activity4} = CommonAPI.post(user, %{"status" => "https://192.168.10.40/notice/9kCP7V"})
-    {:ok, activity5} = CommonAPI.post(user, %{"status" => "https://pleroma.local/notice/9kCP7V"})
+    {:ok, activity2} = CommonAPI.post(user, %{status: "https://10.111.10.1/notice/9kCP7V"})
+    {:ok, activity3} = CommonAPI.post(user, %{status: "https://172.16.32.40/notice/9kCP7V"})
+    {:ok, activity4} = CommonAPI.post(user, %{status: "https://192.168.10.40/notice/9kCP7V"})
+    {:ok, activity5} = CommonAPI.post(user, %{status: "https://pleroma.local/notice/9kCP7V"})
 
     Config.put([:rich_media, :enabled], true)
 
diff --git a/test/web/static_fe/static_fe_controller_test.exs b/test/web/static_fe/static_fe_controller_test.exs
index 430683ea0..a49ab002f 100644
--- a/test/web/static_fe/static_fe_controller_test.exs
+++ b/test/web/static_fe/static_fe_controller_test.exs
@@ -32,8 +32,8 @@ test "404 when user not found", %{conn: conn} do
     end
 
     test "profile does not include private messages", %{conn: conn, user: user} do
-      CommonAPI.post(user, %{"status" => "public"})
-      CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
+      CommonAPI.post(user, %{status: "public"})
+      CommonAPI.post(user, %{status: "private", visibility: "private"})
 
       conn = get(conn, "/users/#{user.nickname}")
 
@@ -44,7 +44,7 @@ test "profile does not include private messages", %{conn: conn, user: user} do
     end
 
     test "pagination", %{conn: conn, user: user} do
-      Enum.map(1..30, fn i -> CommonAPI.post(user, %{"status" => "test#{i}"}) end)
+      Enum.map(1..30, fn i -> CommonAPI.post(user, %{status: "test#{i}"}) end)
 
       conn = get(conn, "/users/#{user.nickname}")
 
@@ -57,7 +57,7 @@ test "pagination", %{conn: conn, user: user} do
     end
 
     test "pagination, page 2", %{conn: conn, user: user} do
-      activities = Enum.map(1..30, fn i -> CommonAPI.post(user, %{"status" => "test#{i}"}) end)
+      activities = Enum.map(1..30, fn i -> CommonAPI.post(user, %{status: "test#{i}"}) end)
       {:ok, a11} = Enum.at(activities, 11)
 
       conn = get(conn, "/users/#{user.nickname}?max_id=#{a11.id}")
@@ -77,7 +77,7 @@ test "it requires authentication if instance is NOT federating", %{conn: conn, u
 
   describe "notice html" do
     test "single notice page", %{conn: conn, user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "testing a thing!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})
 
       conn = get(conn, "/notice/#{activity.id}")
 
@@ -89,7 +89,7 @@ test "single notice page", %{conn: conn, user: user} do
 
     test "filters HTML tags", %{conn: conn} do
       user = insert(:user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "<script>alert('xss')</script>"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "<script>alert('xss')</script>"})
 
       conn =
         conn
@@ -101,11 +101,11 @@ test "filters HTML tags", %{conn: conn} do
     end
 
     test "shows the whole thread", %{conn: conn, user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "space: the final frontier"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "space: the final frontier"})
 
       CommonAPI.post(user, %{
-        "status" => "these are the voyages or something",
-        "in_reply_to_status_id" => activity.id
+        status: "these are the voyages or something",
+        in_reply_to_status_id: activity.id
       })
 
       conn = get(conn, "/notice/#{activity.id}")
@@ -117,7 +117,7 @@ test "shows the whole thread", %{conn: conn, user: user} do
 
     test "redirect by AP object ID", %{conn: conn, user: user} do
       {:ok, %Activity{data: %{"object" => object_url}}} =
-        CommonAPI.post(user, %{"status" => "beam me up"})
+        CommonAPI.post(user, %{status: "beam me up"})
 
       conn = get(conn, URI.parse(object_url).path)
 
@@ -126,7 +126,7 @@ test "redirect by AP object ID", %{conn: conn, user: user} do
 
     test "redirect by activity ID", %{conn: conn, user: user} do
       {:ok, %Activity{data: %{"id" => id}}} =
-        CommonAPI.post(user, %{"status" => "I'm a doctor, not a devops!"})
+        CommonAPI.post(user, %{status: "I'm a doctor, not a devops!"})
 
       conn = get(conn, URI.parse(id).path)
 
@@ -140,8 +140,7 @@ test "404 when notice not found", %{conn: conn} do
     end
 
     test "404 for private status", %{conn: conn, user: user} do
-      {:ok, activity} =
-        CommonAPI.post(user, %{"status" => "don't show me!", "visibility" => "private"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "don't show me!", visibility: "private"})
 
       conn = get(conn, "/notice/#{activity.id}")
 
@@ -171,7 +170,7 @@ test "302 for remote cached status", %{conn: conn, user: user} do
     end
 
     test "it requires authentication if instance is NOT federating", %{conn: conn, user: user} do
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "testing a thing!"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})
 
       ensure_federating_or_authenticated(conn, "/notice/#{activity.id}", user)
     end
diff --git a/test/web/streamer/streamer_test.exs b/test/web/streamer/streamer_test.exs
index ee530f4e9..95b7d1420 100644
--- a/test/web/streamer/streamer_test.exs
+++ b/test/web/streamer/streamer_test.exs
@@ -17,6 +17,76 @@ defmodule Pleroma.Web.StreamerTest do
 
   setup do: clear_config([:instance, :skip_thread_containment])
 
+  describe "get_topic without an user" do
+    test "allows public" do
+      assert {:ok, "public"} = Streamer.get_topic("public", nil)
+      assert {:ok, "public:local"} = Streamer.get_topic("public:local", nil)
+      assert {:ok, "public:media"} = Streamer.get_topic("public:media", nil)
+      assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", nil)
+    end
+
+    test "allows hashtag streams" do
+      assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", nil, %{"tag" => "cofe"})
+    end
+
+    test "disallows user streams" do
+      assert {:error, _} = Streamer.get_topic("user", nil)
+      assert {:error, _} = Streamer.get_topic("user:notification", nil)
+      assert {:error, _} = Streamer.get_topic("direct", nil)
+    end
+
+    test "disallows list streams" do
+      assert {:error, _} = Streamer.get_topic("list", nil, %{"list" => 42})
+    end
+  end
+
+  describe "get_topic with an user" do
+    setup do
+      user = insert(:user)
+      {:ok, %{user: user}}
+    end
+
+    test "allows public streams", %{user: user} do
+      assert {:ok, "public"} = Streamer.get_topic("public", user)
+      assert {:ok, "public:local"} = Streamer.get_topic("public:local", user)
+      assert {:ok, "public:media"} = Streamer.get_topic("public:media", user)
+      assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", user)
+    end
+
+    test "allows user streams", %{user: user} do
+      expected_user_topic = "user:#{user.id}"
+      expected_notif_topic = "user:notification:#{user.id}"
+      expected_direct_topic = "direct:#{user.id}"
+      assert {:ok, ^expected_user_topic} = Streamer.get_topic("user", user)
+      assert {:ok, ^expected_notif_topic} = Streamer.get_topic("user:notification", user)
+      assert {:ok, ^expected_direct_topic} = Streamer.get_topic("direct", user)
+    end
+
+    test "allows hashtag streams", %{user: user} do
+      assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", user, %{"tag" => "cofe"})
+    end
+
+    test "disallows registering to an user stream", %{user: user} do
+      another_user = insert(:user)
+      assert {:error, _} = Streamer.get_topic("user:#{another_user.id}", user)
+      assert {:error, _} = Streamer.get_topic("user:notification:#{another_user.id}", user)
+      assert {:error, _} = Streamer.get_topic("direct:#{another_user.id}", user)
+    end
+
+    test "allows list stream that are owned by the user", %{user: user} do
+      {:ok, list} = List.create("Test", user)
+      assert {:error, _} = Streamer.get_topic("list:#{list.id}", user)
+      assert {:ok, _} = Streamer.get_topic("list", user, %{"list" => list.id})
+    end
+
+    test "disallows list stream that are not owned by the user", %{user: user} do
+      another_user = insert(:user)
+      {:ok, list} = List.create("Test", another_user)
+      assert {:error, _} = Streamer.get_topic("list:#{list.id}", user)
+      assert {:error, _} = Streamer.get_topic("list", user, %{"list" => list.id})
+    end
+  end
+
   describe "user streams" do
     setup do
       user = insert(:user)
@@ -25,17 +95,17 @@ defmodule Pleroma.Web.StreamerTest do
     end
 
     test "it streams the user's post in the 'user' stream", %{user: user} do
-      Streamer.add_socket("user", user)
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
+      Streamer.get_topic_and_add_socket("user", user)
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
       assert_receive {:render_with_user, _, _, ^activity}
       refute Streamer.filtered_by_user?(user, activity)
     end
 
     test "it streams boosts of the user in the 'user' stream", %{user: user} do
-      Streamer.add_socket("user", user)
+      Streamer.get_topic_and_add_socket("user", user)
 
       other_user = insert(:user)
-      {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"})
+      {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
       {:ok, announce, _} = CommonAPI.repeat(activity.id, user)
 
       assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
@@ -43,14 +113,14 @@ test "it streams boosts of the user in the 'user' stream", %{user: user} do
     end
 
     test "it sends notify to in the 'user' stream", %{user: user, notify: notify} do
-      Streamer.add_socket("user", user)
+      Streamer.get_topic_and_add_socket("user", user)
       Streamer.stream("user", notify)
       assert_receive {:render_with_user, _, _, ^notify}
       refute Streamer.filtered_by_user?(user, notify)
     end
 
     test "it sends notify to in the 'user:notification' stream", %{user: user, notify: notify} do
-      Streamer.add_socket("user:notification", user)
+      Streamer.get_topic_and_add_socket("user:notification", user)
       Streamer.stream("user:notification", notify)
       assert_receive {:render_with_user, _, _, ^notify}
       refute Streamer.filtered_by_user?(user, notify)
@@ -62,9 +132,9 @@ test "it doesn't send notify to the 'user:notification' stream when a user is bl
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 
-      Streamer.add_socket("user:notification", user)
+      Streamer.get_topic_and_add_socket("user:notification", user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => ":("})
+      {:ok, activity} = CommonAPI.post(user, %{status: ":("})
       {:ok, _} = CommonAPI.favorite(blocked, activity.id)
 
       refute_receive _
@@ -75,10 +145,10 @@ test "it doesn't send notify to the 'user:notification' stream when a thread is
     } do
       user2 = insert(:user)
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
       {:ok, _} = CommonAPI.add_mute(user, activity)
 
-      Streamer.add_socket("user:notification", user)
+      Streamer.get_topic_and_add_socket("user:notification", user)
 
       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 
@@ -91,8 +161,8 @@ test "it sends favorite to 'user:notification' stream'", %{
     } do
       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
-      Streamer.add_socket("user:notification", user)
+      {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
+      Streamer.get_topic_and_add_socket("user:notification", user)
       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 
       assert_receive {:render_with_user, _, "notification.json", notif}
@@ -106,8 +176,8 @@ test "it doesn't send the 'user:notification' stream' when a domain is blocked",
       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 
       {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
-      {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
-      Streamer.add_socket("user:notification", user)
+      {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
+      Streamer.get_topic_and_add_socket("user:notification", user)
       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 
       refute_receive _
@@ -130,7 +200,7 @@ test "it sends follow activities to the 'user:notification' stream", %{
           %Tesla.Env{status: 200, body: body}
       end)
 
-      Streamer.add_socket("user:notification", user)
+      Streamer.get_topic_and_add_socket("user:notification", user)
       {:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user2, user)
 
       assert_receive {:render_with_user, _, "notification.json", notif}
@@ -143,9 +213,9 @@ test "it sends to public authenticated" do
     user = insert(:user)
     other_user = insert(:user)
 
-    Streamer.add_socket("public", other_user)
+    Streamer.get_topic_and_add_socket("public", other_user)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Test"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
     assert_receive {:render_with_user, _, _, ^activity}
     refute Streamer.filtered_by_user?(user, activity)
   end
@@ -153,9 +223,9 @@ test "it sends to public authenticated" do
   test "works for deletions" do
     user = insert(:user)
     other_user = insert(:user)
-    {:ok, activity} = CommonAPI.post(other_user, %{"status" => "Test"})
+    {:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
 
-    Streamer.add_socket("public", user)
+    Streamer.get_topic_and_add_socket("public", user)
 
     {:ok, _} = CommonAPI.delete(activity.id, other_user)
     activity_id = activity.id
@@ -166,9 +236,9 @@ test "works for deletions" do
   test "it sends to public unauthenticated" do
     user = insert(:user)
 
-    Streamer.add_socket("public", nil)
+    Streamer.get_topic_and_add_socket("public", nil)
 
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "Test"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
     activity_id = activity.id
     assert_receive {:text, event}
     assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
@@ -195,7 +265,7 @@ test "it filters to user if recipients invalid and thread containment is enabled
             )
         )
 
-      Streamer.add_socket("public", user)
+      Streamer.get_topic_and_add_socket("public", user)
       Streamer.stream("public", activity)
       assert_receive {:render_with_user, _, _, ^activity}
       assert Streamer.filtered_by_user?(user, activity)
@@ -216,7 +286,7 @@ test "it sends message if recipients invalid and thread containment is disabled"
             )
         )
 
-      Streamer.add_socket("public", user)
+      Streamer.get_topic_and_add_socket("public", user)
       Streamer.stream("public", activity)
 
       assert_receive {:render_with_user, _, _, ^activity}
@@ -238,7 +308,7 @@ test "it sends message if recipients invalid and thread containment is enabled b
             )
         )
 
-      Streamer.add_socket("public", user)
+      Streamer.get_topic_and_add_socket("public", user)
       Streamer.stream("public", activity)
 
       assert_receive {:render_with_user, _, _, ^activity}
@@ -252,8 +322,8 @@ test "it filters messages involving blocked users" do
       blocked_user = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked_user)
 
-      Streamer.add_socket("public", user)
-      {:ok, activity} = CommonAPI.post(blocked_user, %{"status" => "Test"})
+      Streamer.get_topic_and_add_socket("public", user)
+      {:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
       assert_receive {:render_with_user, _, _, ^activity}
       assert Streamer.filtered_by_user?(user, activity)
     end
@@ -263,21 +333,21 @@ test "it filters messages transitively involving blocked users" do
       blockee = insert(:user)
       friend = insert(:user)
 
-      Streamer.add_socket("public", blocker)
+      Streamer.get_topic_and_add_socket("public", blocker)
 
       {:ok, _user_relationship} = User.block(blocker, blockee)
 
-      {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
+      {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})
 
       assert_receive {:render_with_user, _, _, ^activity_one}
       assert Streamer.filtered_by_user?(blocker, activity_one)
 
-      {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
+      {:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
 
       assert_receive {:render_with_user, _, _, ^activity_two}
       assert Streamer.filtered_by_user?(blocker, activity_two)
 
-      {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
+      {:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})
 
       assert_receive {:render_with_user, _, _, ^activity_three}
       assert Streamer.filtered_by_user?(blocker, activity_three)
@@ -295,12 +365,12 @@ test "it doesn't send unwanted DMs to list" do
       {:ok, list} = List.create("Test", user_a)
       {:ok, list} = List.follow(list, user_b)
 
-      Streamer.add_socket("list:#{list.id}", user_a)
+      Streamer.get_topic_and_add_socket("list", user_a, %{"list" => list.id})
 
       {:ok, _activity} =
         CommonAPI.post(user_b, %{
-          "status" => "@#{user_c.nickname} Test",
-          "visibility" => "direct"
+          status: "@#{user_c.nickname} Test",
+          visibility: "direct"
         })
 
       refute_receive _
@@ -313,12 +383,12 @@ test "it doesn't send unwanted private posts to list" do
       {:ok, list} = List.create("Test", user_a)
       {:ok, list} = List.follow(list, user_b)
 
-      Streamer.add_socket("list:#{list.id}", user_a)
+      Streamer.get_topic_and_add_socket("list", user_a, %{"list" => list.id})
 
       {:ok, _activity} =
         CommonAPI.post(user_b, %{
-          "status" => "Test",
-          "visibility" => "private"
+          status: "Test",
+          visibility: "private"
         })
 
       refute_receive _
@@ -333,12 +403,12 @@ test "it sends wanted private posts to list" do
       {:ok, list} = List.create("Test", user_a)
       {:ok, list} = List.follow(list, user_b)
 
-      Streamer.add_socket("list:#{list.id}", user_a)
+      Streamer.get_topic_and_add_socket("list", user_a, %{"list" => list.id})
 
       {:ok, activity} =
         CommonAPI.post(user_b, %{
-          "status" => "Test",
-          "visibility" => "private"
+          status: "Test",
+          visibility: "private"
         })
 
       assert_receive {:render_with_user, _, _, ^activity}
@@ -354,9 +424,9 @@ test "it filters muted reblogs" do
       CommonAPI.follow(user1, user2)
       CommonAPI.hide_reblogs(user1, user2)
 
-      {:ok, create_activity} = CommonAPI.post(user3, %{"status" => "I'm kawen"})
+      {:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})
 
-      Streamer.add_socket("user", user1)
+      Streamer.get_topic_and_add_socket("user", user1)
       {:ok, announce_activity, _} = CommonAPI.repeat(create_activity.id, user2)
       assert_receive {:render_with_user, _, _, ^announce_activity}
       assert Streamer.filtered_by_user?(user1, announce_activity)
@@ -368,8 +438,8 @@ test "it filters reblog notification for reblog-muted actors" do
       CommonAPI.follow(user1, user2)
       CommonAPI.hide_reblogs(user1, user2)
 
-      {:ok, create_activity} = CommonAPI.post(user1, %{"status" => "I'm kawen"})
-      Streamer.add_socket("user", user1)
+      {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
+      Streamer.get_topic_and_add_socket("user", user1)
       {:ok, _favorite_activity, _} = CommonAPI.repeat(create_activity.id, user2)
 
       assert_receive {:render_with_user, _, "notification.json", notif}
@@ -382,8 +452,8 @@ test "it send non-reblog notification for reblog-muted actors" do
       CommonAPI.follow(user1, user2)
       CommonAPI.hide_reblogs(user1, user2)
 
-      {:ok, create_activity} = CommonAPI.post(user1, %{"status" => "I'm kawen"})
-      Streamer.add_socket("user", user1)
+      {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
+      Streamer.get_topic_and_add_socket("user", user1)
       {:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id)
 
       assert_receive {:render_with_user, _, "notification.json", notif}
@@ -394,9 +464,9 @@ test "it send non-reblog notification for reblog-muted actors" do
   test "it filters posts from muted threads" do
     user = insert(:user)
     user2 = insert(:user)
-    Streamer.add_socket("user", user2)
+    Streamer.get_topic_and_add_socket("user", user2)
     {:ok, user2, user, _activity} = CommonAPI.follow(user2, user)
-    {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
+    {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
     {:ok, _} = CommonAPI.add_mute(user2, activity)
     assert_receive {:render_with_user, _, _, ^activity}
     assert Streamer.filtered_by_user?(user2, activity)
@@ -411,12 +481,12 @@ test "it sends conversation update to the 'direct' stream", %{} do
       user = insert(:user)
       another_user = insert(:user)
 
-      Streamer.add_socket("direct", user)
+      Streamer.get_topic_and_add_socket("direct", user)
 
       {:ok, _create_activity} =
         CommonAPI.post(another_user, %{
-          "status" => "hey @#{user.nickname}",
-          "visibility" => "direct"
+          status: "hey @#{user.nickname}",
+          visibility: "direct"
         })
 
       assert_receive {:text, received_event}
@@ -433,12 +503,12 @@ test "it doesn't send conversation update to the 'direct' stream when the last m
       user = insert(:user)
       another_user = insert(:user)
 
-      Streamer.add_socket("direct", user)
+      Streamer.get_topic_and_add_socket("direct", user)
 
       {:ok, create_activity} =
         CommonAPI.post(another_user, %{
-          "status" => "hi @#{user.nickname}",
-          "visibility" => "direct"
+          status: "hi @#{user.nickname}",
+          visibility: "direct"
         })
 
       create_activity_id = create_activity.id
@@ -459,19 +529,19 @@ test "it doesn't send conversation update to the 'direct' stream when the last m
     test "it sends conversation update to the 'direct' stream when a message is deleted" do
       user = insert(:user)
       another_user = insert(:user)
-      Streamer.add_socket("direct", user)
+      Streamer.get_topic_and_add_socket("direct", user)
 
       {:ok, create_activity} =
         CommonAPI.post(another_user, %{
-          "status" => "hi @#{user.nickname}",
-          "visibility" => "direct"
+          status: "hi @#{user.nickname}",
+          visibility: "direct"
         })
 
       {:ok, create_activity2} =
         CommonAPI.post(another_user, %{
-          "status" => "hi @#{user.nickname} 2",
-          "in_reply_to_status_id" => create_activity.id,
-          "visibility" => "direct"
+          status: "hi @#{user.nickname} 2",
+          in_reply_to_status_id: create_activity.id,
+          visibility: "direct"
         })
 
       assert_receive {:render_with_user, _, _, ^create_activity}
diff --git a/test/web/twitter_api/password_controller_test.exs b/test/web/twitter_api/password_controller_test.exs
index 0a24860d3..231a46c67 100644
--- a/test/web/twitter_api/password_controller_test.exs
+++ b/test/web/twitter_api/password_controller_test.exs
@@ -54,7 +54,7 @@ test "it returns HTTP 200", %{conn: conn} do
       assert response =~ "<h2>Password changed!</h2>"
 
       user = refresh_record(user)
-      assert Comeonin.Pbkdf2.checkpw("test", user.password_hash)
+      assert Pbkdf2.verify_pass("test", user.password_hash)
       assert Enum.empty?(Token.get_user_tokens(user))
     end
 
diff --git a/test/web/twitter_api/util_controller_test.exs b/test/web/twitter_api/util_controller_test.exs
index b701239a0..ad919d341 100644
--- a/test/web/twitter_api/util_controller_test.exs
+++ b/test/web/twitter_api/util_controller_test.exs
@@ -688,7 +688,7 @@ test "with proper permissions, valid password and matching new password and conf
 
       assert json_response(conn, 200) == %{"status" => "success"}
       fetched_user = User.get_cached_by_id(user.id)
-      assert Comeonin.Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
+      assert Pbkdf2.verify_pass("newpass", fetched_user.password_hash) == true
     end
   end
 
diff --git a/test/workers/cron/digest_emails_worker_test.exs b/test/workers/cron/digest_emails_worker_test.exs
index 0a63bf4e0..f9bc50db5 100644
--- a/test/workers/cron/digest_emails_worker_test.exs
+++ b/test/workers/cron/digest_emails_worker_test.exs
@@ -29,7 +29,7 @@ defmodule Pleroma.Workers.Cron.DigestEmailsWorkerTest do
 
     user2 = insert(:user, last_digest_emailed_at: date)
     {:ok, _} = User.switch_email_notifications(user2, "digest", true)
-    CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}!"})
+    CommonAPI.post(user, %{status: "hey @#{user2.nickname}!"})
 
     {:ok, user2: user2}
   end
diff --git a/test/workers/cron/new_users_digest_worker_test.exs b/test/workers/cron/new_users_digest_worker_test.exs
index e6d050ecc..54cf0ca46 100644
--- a/test/workers/cron/new_users_digest_worker_test.exs
+++ b/test/workers/cron/new_users_digest_worker_test.exs
@@ -15,7 +15,7 @@ test "it sends new users digest emails" do
     admin = insert(:user, %{is_admin: true})
     user = insert(:user, %{inserted_at: yesterday})
     user2 = insert(:user, %{inserted_at: yesterday})
-    CommonAPI.post(user, %{"status" => "cofe"})
+    CommonAPI.post(user, %{status: "cofe"})
 
     NewUsersDigestWorker.perform(nil, nil)
     ObanHelpers.perform_all()
@@ -36,7 +36,7 @@ test "it doesn't fail when admin has no email" do
     insert(:user, %{inserted_at: yesterday})
     user = insert(:user, %{inserted_at: yesterday})
 
-    CommonAPI.post(user, %{"status" => "cofe"})
+    CommonAPI.post(user, %{status: "cofe"})
 
     NewUsersDigestWorker.perform(nil, nil)
     ObanHelpers.perform_all()