No OneTemporary
Actions

Authored By

Unknown

Size

281 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/changelog.d/activitypub-bot-rfc9421-fallback.fix b/changelog.d/activitypub-bot-rfc9421-fallback.fix
	new file mode 100644
	index 000000000..a04940bfe
	--- /dev/null
	+++ b/changelog.d/activitypub-bot-rfc9421-fallback.fix
	@@ -0,0 +1 @@
	+Reject unsupported or ambiguous inbox signatures instead of queueing a doomed failed-signature retry, allowing clients to fall back to legacy HTTP Signatures.
	diff --git a/changelog.d/fedidev-federation-compat.add b/changelog.d/fedidev-federation-compat.add
	new file mode 100644
	index 000000000..bb29925f9
	--- /dev/null
	+++ b/changelog.d/fedidev-federation-compat.add
	@@ -0,0 +1 @@
	+Accept more real-world ActivityPub object shapes collected by fedidev.fun
	diff --git a/lib/pleroma/object/containment.ex b/lib/pleroma/object/containment.ex
	index 77fac12c0..c4cc1f014 100644
	--- a/lib/pleroma/object/containment.ex
	+++ b/lib/pleroma/object/containment.ex
	@@ -1,101 +1,115 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Containment do
	@moduledoc """
	This module contains some useful functions for containing objects to specific
	origins and determining those origins. They previously lived in the
	ActivityPub `Transmogrifier` module.

	Object containment is an important step in validating remote objects to prevent
	spoofing, therefore removal of object containment functions is NOT recommended.
	"""
	def get_actor(%{"actor" => actor}) when is_binary(actor) do
	actor
	end

	+ def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	+ get_actor(%{"actor" => actor})
	+ end
	+
	+ def get_actor(%{"actor" => nil}), do: nil
	+
	+ def get_actor(%{"actor" => []}), do: nil
	+
	def get_actor(%{"actor" => actor}) when is_list(actor) do
	- if is_binary(Enum.at(actor, 0)) do
	- Enum.at(actor, 0)
	- else
	- Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
	- \|> Map.get("id")
	+ case actor do
	+ [first \| _] when is_binary(first) ->
	+ first
	+
	+ _ ->
	+ Enum.find_value(actor, fn
	+ %{"type" => type, "id" => id}
	+ when type in ["Person", "Service", "Application"] and is_binary(id) ->
	+ id
	+
	+ _ ->
	+ nil
	+ end)
	end
	end

	def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
	id
	end

	- def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	- get_actor(%{"actor" => actor})
	- end
	-
	def get_object(%{"object" => id}) when is_binary(id) do
	id
	end

	def get_object(%{"object" => %{"id" => id}}) when is_binary(id) do
	id
	end

	def get_object(_) do
	nil
	end

	defp compare_uris(%URI{host: host} = _id_uri, %URI{host: host} = _other_uri), do: :ok
	defp compare_uris(_id_uri, _other_uri), do: :error

	@doc """
	Checks whether an URL to fetch from is from the local server.

	We never want to fetch from ourselves; if it's not in the database
	it can't be authentic and must be a counterfeit.
	"""
	def contain_local_fetch(id) do
	case compare_uris(URI.parse(id), Pleroma.Web.Endpoint.struct_url()) do
	:ok -> :error
	_ -> :ok
	end
	end

	@doc """
	Checks that an imported AP object's actor matches the host it came from.
	"""
	def contain_origin(_id, %{"actor" => nil}), do: :error

	def contain_origin(id, %{"actor" => _actor} = params) do
	id_uri = URI.parse(id)
	- actor_uri = URI.parse(get_actor(params))

	- compare_uris(actor_uri, id_uri)
	+ case get_actor(params) do
	+ actor when is_binary(actor) -> compare_uris(URI.parse(actor), id_uri)
	+ _ -> :error
	+ end
	end

	def contain_origin(id, %{"attributedTo" => actor} = params),
	do: contain_origin(id, Map.put(params, "actor", actor))

	def contain_origin(_id, _data), do: :error

	def contain_origin_from_id(id, %{"id" => other_id} = _params) when is_binary(other_id) do
	id_uri = URI.parse(id)
	other_uri = URI.parse(other_id)

	compare_uris(id_uri, other_uri)
	end

	# Mastodon pin activities don't have an id, so we check the object field, which will be pinned.
	def contain_origin_from_id(id, %{"object" => object}) when is_binary(object) do
	id_uri = URI.parse(id)
	object_uri = URI.parse(object)

	compare_uris(id_uri, object_uri)
	end

	def contain_origin_from_id(_id, _data), do: :error

	def contain_child(%{"object" => %{"id" => id, "attributedTo" => _} = object}),
	do: contain_origin(id, object)

	def contain_child(_), do: :ok
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index 3d1875599..38b8b8bfc 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,648 +1,681 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.ControllerHelper
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Federator
	alias Pleroma.Web.Plugs.EnsureAuthenticatedPlug
	alias Pleroma.Web.Plugs.FederatingPlug

	require Logger

	action_fallback(:errors)

	@federating_only_actions [:internal_fetch, :relay, :relay_following, :relay_followers]

	@object_replies_known_param_keys ["page", "min_id", "max_id", "since_id", "limit"]

	plug(FederatingPlug when action in @federating_only_actions)

	plug(
	EnsureAuthenticatedPlug,
	[unless_func: &FederatingPlug.federating?/1] when action not in @federating_only_actions
	)

	# Note: :following and :followers must be served even without authentication (as via :api)
	plug(
	EnsureAuthenticatedPlug
	when action in [:read_inbox, :update_outbox, :whoami, :upload_media]
	)

	plug(Majic.Plug, [pool: Pleroma.MajicPool] when action in [:upload_media])

	plug(
	Pleroma.Web.Plugs.Cache,
	[query_params: false, tracking_fun: &__MODULE__.track_object_fetch/2]
	when action in [:activity, :object]
	)

	plug(:log_inbox_metadata when action in [:inbox])
	plug(:relay_active? when action in [:relay])

	defp relay_active?(conn, _) do
	if Pleroma.Config.get([:instance, :allow_relay]) do
	conn
	else
	conn
	\|> render_error(:not_found, "not found")
	\|> halt()
	end
	end

	def user(conn, %{"nickname" => nickname}) do
	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	else
	nil -> {:error, :not_found}
	%{local: false} -> {:error, :not_found}
	end
	end

	def object(%{assigns: assigns} = conn, _) do
	with ap_id <- Endpoint.url() <> conn.request_path,
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	user <- Map.get(assigns, :user, nil),
	{_, true} <- {:visible?, Visibility.visible_for_user?(object, user)} do
	conn
	\|> maybe_skip_cache(user)
	\|> assign(:tracking_fun_data, object.id)
	\|> set_cache_ttl_for(object)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object.json", object: object)
	else
	{:visible?, false} -> {:error, :not_found}
	nil -> {:error, :not_found}
	end
	end

	def object_replies(%{assigns: assigns, query_params: params} = conn, _all_params) do
	object_ap_id = conn.path_info \|> Enum.reverse() \|> tl() \|> Enum.reverse()
	object_ap_id = Endpoint.url() <> "/" <> Enum.join(object_ap_id, "/")

	# Most other API params are converted to atoms by OpenAPISpex 3.x
	# and therefore helper functions assume atoms. For consistency,
	# also convert our params to atoms here.
	params =
	params
	\|> Map.take(@object_replies_known_param_keys)
	\|> Enum.into(%{}, fn {k, v} -> {String.to_existing_atom(k), v} end)
	\|> Map.put(:object_ap_id, object_ap_id)
	\|> Map.put(:order_asc, true)
	\|> Map.put(:conn, conn)

	with %Object{} = object <- Object.get_cached_by_ap_id(object_ap_id),
	user <- Map.get(assigns, :user, nil),
	{_, true} <- {:visible?, Visibility.visible_for_user?(object, user)} do
	conn
	\|> maybe_skip_cache(user)
	\|> set_cache_ttl_for(object)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object_replies.json", render_params: params)
	else
	{:visible?, false} -> {:error, :not_found}
	nil -> {:error, :not_found}
	end
	end

	def track_object_fetch(conn, nil), do: conn

	def track_object_fetch(conn, object_id) do
	with %{assigns: %{user: %User{id: user_id}}} <- conn do
	Delivery.create(object_id, user_id)
	end

	conn
	end

	def activity(%{assigns: assigns} = conn, _) do
	with ap_id <- Endpoint.url() <> conn.request_path,
	%Activity{} = activity <- Activity.normalize(ap_id),
	{_, true} <- {:local?, activity.local},
	user <- Map.get(assigns, :user, nil),
	{_, true} <- {:visible?, Visibility.visible_for_user?(activity, user)} do
	conn
	\|> maybe_skip_cache(user)
	\|> maybe_set_tracking_data(activity)
	\|> set_cache_ttl_for(activity)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object.json", object: activity)
	else
	{:visible?, false} -> {:error, :not_found}
	{:local?, false} -> {:error, :not_found}
	nil -> {:error, :not_found}
	end
	end

	defp maybe_set_tracking_data(conn, %Activity{data: %{"type" => "Create"}} = activity) do
	object_id = Object.normalize(activity, fetch: false).id
	assign(conn, :tracking_fun_data, object_id)
	end

	defp maybe_set_tracking_data(conn, _activity), do: conn

	defp set_cache_ttl_for(conn, %Activity{object: object}) do
	set_cache_ttl_for(conn, object)
	end

	defp set_cache_ttl_for(conn, entity) do
	ttl =
	case entity do
	%Object{data: %{"type" => "Question"}} ->
	Pleroma.Config.get([:web_cache_ttl, :activity_pub_question])

	%Object{} ->
	Pleroma.Config.get([:web_cache_ttl, :activity_pub])

	_ ->
	nil
	end

	assign(conn, :cache_ttl, ttl)
	end

	def maybe_skip_cache(conn, user) do
	if user do
	conn
	\|> assign(:skip_cache, true)
	else
	conn
	end
	end

	# GET /relay/following
	def relay_following(conn, _params) do
	with %{halted: false} = conn <- FederatingPlug.call(conn, []) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: Relay.get_actor()})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:show_follows, true} <-
	{:show_follows, (for_user && for_user == user) \|\| !user.hide_follows} do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: user, page: page, for: for_user})
	else
	{:show_follows, _} ->
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> send_resp(403, "")
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: user, for: for_user})
	end
	end

	# GET /relay/followers
	def relay_followers(conn, _params) do
	with %{halted: false} = conn <- FederatingPlug.call(conn, []) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: Relay.get_actor()})
	end
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:show_followers, true} <-
	{:show_followers, (for_user && for_user == user) \|\| !user.hide_followers} do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: user, page: page, for: for_user})
	else
	{:show_followers, _} ->
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> send_resp(403, "")
	end
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: user, for: for_user})
	end
	end

	def outbox(
	%{assigns: %{user: for_user}} = conn,
	%{"nickname" => nickname, "page" => page?} = params
	)
	when page? in [true, "true"] do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	# "include_poll_votes" is a hack because postgres generates inefficient
	# queries when filtering by 'Answer', poll votes will be hidden by the
	# visibility filter in this case anyway
	params =
	params
	\|> Map.drop(["nickname", "page"])
	\|> Map.put("include_poll_votes", true)
	\|> Map.new(fn {k, v} -> {String.to_existing_atom(k), v} end)

	activities = ActivityPub.fetch_user_activities(user, for_user, params)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection_page.json", %{
	activities: activities,
	pagination: ControllerHelper.get_pagination_fields(conn, activities)
	})
	end
	end

	def outbox(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection.json", %{iri: "#{user.ap_id}/outbox"})
	end
	end

	def inbox(
	%{
	assigns: %{valid_signature: true, valid_host_header: true}
	} = conn,
	%{"nickname" => nickname} = params
	) do
	- with {:recipient_exists, %User{} = recipient} <-
	+ with false <- unsupported_http_message_signature?(conn),
	+ {:recipient_exists, %User{} = recipient} <-
	{:recipient_exists, User.get_cached_by_nickname(nickname)},
	{:sender_exists, {:ok, %User{} = actor}} <-
	{:sender_exists, User.get_or_fetch_by_ap_id(params["actor"])},
	{:recipient_active, true} <- {:recipient_active, recipient.is_active},
	{:sender_active, true} <- {:sender_active, actor.is_active},
	true <- Utils.recipient_in_message(recipient, actor, params),
	params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	else
	+ true ->
	+ reject_unsupported_http_message_signature(conn)
	+
	{:recipient_exists, _} ->
	conn
	\|> put_status(:not_found)
	\|> json("User does not exist")

	{:sender_exists, _} ->
	conn
	\|> put_status(:not_found)
	\|> json("Sender does not exist")

	{:recipient_active, _} ->
	conn
	\|> put_status(:not_found)
	\|> json("User deactivated")

	{:sender_active, _} ->
	conn
	\|> put_status(:not_found)
	\|> json("Sender deactivated")

	_ ->
	conn
	\|> put_status(:bad_request)
	\|> json("Invalid request.")
	end
	end

	def inbox(%{assigns: %{valid_signature: true, valid_host_header: true}} = conn, params) do
	- Federator.incoming_ap_doc(params)
	- json(conn, "ok")
	+ if unsupported_http_message_signature?(conn) do
	+ reject_unsupported_http_message_signature(conn)
	+ else
	+ Federator.incoming_ap_doc(params)
	+ json(conn, "ok")
	+ end
	end

	def inbox(%{assigns: %{valid_signature: false}} = conn, params) do
	- Federator.incoming_failed_signature_ap_doc(%{
	- method: conn.method,
	- req_headers: conn.req_headers,
	- request_path: conn.request_path,
	- params: params,
	- query_string: conn.query_string
	- })
	+ if unsupported_http_message_signature?(conn) do
	+ reject_unsupported_http_message_signature(conn)
	+ else
	+ Federator.incoming_failed_signature_ap_doc(%{
	+ method: conn.method,
	+ req_headers: conn.req_headers,
	+ request_path: conn.request_path,
	+ params: params,
	+ query_string: conn.query_string
	+ })

	- json(conn, "ok")
	+ json(conn, "ok")
	+ end
	end

	# POST /relay/inbox -or- POST /internal/fetch/inbox
	def inbox(conn, %{"type" => "Create"} = params) do
	if FederatingPlug.federating?() do
	post_inbox_relayed_create(conn, params)
	else
	conn
	\|> put_status(403)
	\|> json("Not federating")
	end
	end

	def inbox(conn, _params) do
	conn
	\|> put_status(:bad_request)
	\|> json("error, missing HTTP Signature")
	end

	+ defp reject_unsupported_http_message_signature(conn) do
	+ conn
	+ \|> put_status(:unauthorized)
	+ \|> json("error, unsupported HTTP Message Signature")
	+ end
	+
	+ defp unsupported_http_message_signature?(conn) do
	+ signature_headers = Plug.Conn.get_req_header(conn, "signature")
	+
	+ multiple_signature_headers?(signature_headers) or
	+ (Plug.Conn.get_req_header(conn, "signature-input") != [] and
	+ not cavage_signature?(signature_headers))
	+ end
	+
	+ defp multiple_signature_headers?([_, _ \| _]), do: true
	+ defp multiple_signature_headers?(_), do: false
	+
	+ defp cavage_signature?(signature_headers) do
	+ Enum.any?(signature_headers, &Regex.match?(~r/(^\|,)\skeyId\s=/, &1))
	+ end
	+
	defp post_inbox_relayed_create(conn, params) do
	Logger.debug(
	"Signature missing or not from author, relayed Create message, fetching object from source"
	)

	Fetcher.fetch_object_from_id(params["object"]["id"])

	json(conn, "ok")
	end

	defp represent_service_actor(%User{} = user, conn) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	end

	defp represent_service_actor(nil, _), do: {:error, :not_found}

	def relay(conn, _params) do
	Relay.get_actor()
	\|> represent_service_actor(conn)
	end

	def internal_fetch(conn, _params) do
	InternalFetchActor.get_actor()
	\|> represent_service_actor(conn)
	end

	@doc "Returns the authenticated user's ActivityPub User object or a 404 Not Found if non-authenticated"
	def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	end

	def read_inbox(
	%{assigns: %{user: %User{nickname: nickname} = user}} = conn,
	%{"nickname" => nickname, "page" => page?} = params
	)
	when page? in [true, "true"] do
	params =
	params
	\|> Map.drop(["nickname", "page"])
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)
	\|> Map.new(fn {k, v} -> {String.to_existing_atom(k), v} end)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection_page.json", %{
	activities: activities,
	pagination: ControllerHelper.get_pagination_fields(conn, activities)
	})
	end

	def read_inbox(%{assigns: %{user: %User{nickname: nickname} = user}} = conn, %{
	"nickname" => nickname
	}) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection.json", %{iri: "#{user.ap_id}/inbox"})
	end

	def read_inbox(%{assigns: %{user: %User{nickname: as_nickname}}} = conn, %{
	"nickname" => nickname
	}) do
	err =
	dgettext("errors", "can't read inbox of %{nickname} as %{as_nickname}",
	nickname: nickname,
	as_nickname: as_nickname
	)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

	defp fix_user_message(%User{ap_id: actor}, %{"type" => "Create", "object" => object} = activity)
	when is_map(object) do
	length =
	[object["content"], object["summary"], object["name"]]
	\|> Enum.filter(&is_binary(&1))
	\|> Enum.join("")
	\|> String.length()

	limit = Pleroma.Config.get([:instance, :limit])

	if length < limit do
	object =
	object
	\|> Transmogrifier.strip_internal_fields()
	\|> Map.put("attributedTo", actor)
	\|> Map.put("actor", actor)
	\|> Map.put("id", Utils.generate_object_id())

	{:ok, Map.put(activity, "object", object)}
	else
	{:error,
	dgettext(
	"errors",
	"Character limit (%{limit} characters) exceeded, contains %{length} characters",
	limit: limit,
	length: length
	)}
	end
	end

	defp fix_user_message(
	%User{ap_id: actor} = user,
	%{"type" => "Delete", "object" => object} = activity
	) do
	with {_, %Object{data: object_data}} <- {:normalize, Object.normalize(object, fetch: false)},
	{_, true} <- {:permission, user.is_moderator \|\| actor == object_data["actor"]} do
	{:ok, activity}
	else
	{:normalize, _} ->
	{:error, "No such object found"}

	{:permission, _} ->
	{:forbidden, "You can't delete this object"}
	end
	end

	defp fix_user_message(%User{}, activity) do
	{:ok, activity}
	end

	# We currently lack a Flag ObjectValidator since both CommonAPI and Transmogrifier
	# both send it straight to ActivityPub.flag and C2S currently has to go through
	# the normal pipeline which requires an ObjectValidator.
	# TODO: Add a Flag Activity ObjectValidator
	defp check_allowed_action(_, %{"type" => "Flag"}) do
	{:error, "Flag activities aren't currently supported in C2S"}
	end

	# It would respond with 201 and silently fail with:
	# Could not decode featured collection at fetch #{user.ap_id} \
	# {:error, "Trying to fetch local resource"}
	defp check_allowed_action(%{ap_id: ap_id}, %{"type" => "Update", "object" => %{"id" => ap_id}}),
	do: {:error, "Updating profile is not currently supported in C2S"}

	defp check_allowed_action(_, activity), do: {:ok, activity}

	defp validate_visibility(%User{} = user, %{"type" => type, "object" => object} = activity) do
	with {_, %Object{} = normalized_object} <-
	{:normalize, Object.normalize(object, fetch: false)},
	{_, true} <- {:visibility, Visibility.visible_for_user?(normalized_object, user)} do
	{:ok, activity}
	else
	{:normalize, _} ->
	if type in ["Create", "Listen"] do
	# Creating new object via C2S; user is local and authenticated
	# via the :authenticate Plug pipeline.
	{:ok, activity}
	else
	{:error, "No such object found"}
	end

	{:visibility, _} ->
	{:forbidden, "You can't interact with this object"}
	end
	end

	def update_outbox(
	%{assigns: %{user: %User{nickname: nickname, ap_id: actor} = user}} = conn,
	%{"nickname" => nickname} = params
	) do
	params =
	params
	\|> Map.drop(["nickname"])
	\|> Map.put("id", Utils.generate_activity_id())
	\|> Map.put("actor", actor)

	with {:ok, params} <- fix_user_message(user, params),
	{:ok, params} <- check_allowed_action(user, params),
	{:ok, params} <- validate_visibility(user, params),
	{:ok, activity, _} <- Pipeline.common_pipeline(params, local: true),
	%Activity{data: activity_data} <- Activity.normalize(activity) do
	conn
	\|> put_status(:created)
	\|> put_resp_header("location", activity_data["id"])
	\|> json(activity_data)
	else
	{:forbidden, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(message)

	{:error, message} when is_binary(message) ->
	conn
	\|> put_status(:bad_request)
	\|> json(message)

	e ->
	Logger.warning(fn -> "AP C2S: #{inspect(e)}" end)

	conn
	\|> put_status(:bad_request)
	\|> json("Bad Request")
	end
	end

	def update_outbox(%{assigns: %{user: %User{} = user}} = conn, %{"nickname" => nickname}) do
	err =
	dgettext("errors", "can't update outbox of %{nickname} as %{as_nickname}",
	nickname: nickname,
	as_nickname: user.nickname
	)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

	defp errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(:not_found)
	\|> json(dgettext("errors", "Not found"))
	end

	defp errors(conn, _e) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "error"))
	end

	defp log_inbox_metadata(%{params: %{"actor" => actor, "type" => type}} = conn, _) do
	Logger.metadata(actor: actor, type: type)
	conn
	end

	defp log_inbox_metadata(conn, _), do: conn

	def upload_media(%{assigns: %{user: %User{} = user}} = conn, %{"file" => file} = data) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, "description")
	) do
	Logger.debug(inspect(object))

	conn
	\|> put_status(:created)
	\|> json(object.data)
	end
	end

	def pinned(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("featured.json", %{user: user}))
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index 17652a0de..0254d6dc1 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,364 +1,366 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	@behaviour Pleroma.Web.ActivityPub.ObjectValidator.Validating

	import Pleroma.Constants, only: [activity_types: 0, object_types: 0]

	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AddRemoveValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AudioImageVideoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EventValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	@impl true
	def validate(object, meta)

	# This overload works together with the InboxGuardPlug
	# and ensures that we are not accepting any activity type
	# that cannot pass InboxGuardPlug.
	# If we want to support any more activity types, make sure to
	# add it in Pleroma.Constants's activity_types or object_types,
	# and, if applicable, allowed_activity_types_from_strangers.
	def validate(%{"type" => type}, _meta)
	when type not in activity_types() and type not in object_types(),
	do: {:error, :not_allowed_object_type}

	def validate(%{"type" => "Block"} = block_activity, meta) do
	with {:ok, block_activity} <-
	block_activity
	\|> BlockValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	block_activity = stringify_keys(block_activity)
	outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])

	meta =
	if !outgoing_blocks do
	Keyword.put(meta, :do_not_federate, true)
	else
	meta
	end

	{:ok, block_activity, meta}
	end
	end

	def validate(%{"type" => "Undo"} = object, meta) do
	with {:ok, object} <-
	object
	\|> UndoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	undone_object = Activity.get_by_ap_id(object["object"])

	meta =
	meta
	\|> Keyword.put(:object_data, undone_object.data)

	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Delete"} = object, meta) do
	with cng <- DeleteValidator.cast_and_validate(object),
	do_not_federate <- DeleteValidator.do_not_federate?(cng),
	{:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
	object = stringify_keys(object)
	meta = Keyword.put(meta, :do_not_federate, do_not_federate)
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"} = object} = create_activity,
	meta
	) do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateChatMessageValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Image Event Article Note Page] do
	with {:ok, object_data} <-
	object
	+ \|> CommonFixes.maybe_set_attributed_to_from_activity(create_activity)
	\|> CommonFixes.maybe_add_language_from_activity(create_activity)
	\|> cast_and_apply_and_stringify_with_history(),
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, create_activity} <-
	create_activity
	\|> CreateGenericValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Event Question Audio Video Image Article Note Page] do
	validator =
	case type do
	"Event" -> EventValidator
	"Question" -> QuestionValidator
	"Audio" -> AudioImageVideoValidator
	"Video" -> AudioImageVideoValidator
	"Image" -> AudioImageVideoValidator
	"Article" -> ArticleNotePageValidator
	"Note" -> ArticleNotePageValidator
	"Page" -> ArticleNotePageValidator
	end

	with {:ok, object} <-
	do_separate_with_history(object, fn object ->
	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)

	# Insert copy of hashtags as strings for the non-hashtag table indexing
	tag = (object["tag"] \|\| []) ++ Object.hashtags(%Object{data: object})
	object = Map.put(object, "tag", tag)

	{:ok, object}
	end
	end) do
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Update", "object" => %{"type" => objtype} = object} = update_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Event Article Note Page] do
	with {_, false} <- {:local, Access.get(meta, :local, false)},
	{_, {:ok, object_data, _}} <-
	{:object_validation,
	object
	+ \|> CommonFixes.maybe_set_attributed_to_from_activity(update_activity)
	\|> CommonFixes.maybe_add_language_from_activity(update_activity)
	\|> validate(meta)},
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	else
	{:local, _} ->
	with {:ok, object} <-
	update_activity
	\|> UpdateValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end

	{:object_validation, e} ->
	e

	{:error, %Ecto.Changeset{} = e} ->
	{:error, e}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Accept Reject Follow Like EmojiReact Announce
	ChatMessage Answer] do
	validator =
	case type do
	"Accept" -> AcceptRejectValidator
	"Reject" -> AcceptRejectValidator
	"Follow" -> FollowValidator
	"Like" -> LikeValidator
	"EmojiReact" -> EmojiReactValidator
	"Announce" -> AnnounceValidator
	"ChatMessage" -> ChatMessageValidator
	"Answer" -> AnswerValidator
	end

	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => type} = object, meta) when type == "Update" do
	with {:ok, object} <-
	object
	\|> UpdateValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => type} = object, meta) when type in ~w(Add Remove) do
	with {:ok, object} <-
	object
	\|> AddRemoveValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(o, m), do: {:error, {:validator_not_set, {o, m}}}

	def cast_and_apply_and_stringify_with_history(object) do
	do_separate_with_history(object, fn object ->
	with {:ok, object_data} <- cast_and_apply(object),
	object_data <- object_data \|> stringify_keys() do
	{:ok, object_data}
	end
	end)
	end

	def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	ChatMessageValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Question"} = object) do
	QuestionValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Answer"} = object) do
	AnswerValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Audio Image Video] do
	AudioImageVideoValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Event"} = object) do
	EventValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Article Note Page] do
	ArticleNotePageValidator.cast_and_apply(object)
	end

	def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	def stringify_keys(object) when is_struct(object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Enum.filter(fn {_, v} -> v != nil end)
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

	def stringify_keys(object) when is_list(object) do
	object
	\|> Enum.map(&stringify_keys/1)
	end

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	with actor <- Containment.get_actor(object),
	{:ok, actor} <- ObjectValidators.ObjectID.cast(actor) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], fetch: true)
	:ok
	end

	defp for_each_history_item(
	%{"type" => "OrderedCollection", "orderedItems" => items} = history,
	object,
	fun
	) do
	processed_items =
	Enum.map(items, fn item ->
	with item <- Map.put(item, "id", object["id"]),
	{:ok, item} <- fun.(item) do
	item
	else
	_ -> nil
	end
	end)

	if Enum.all?(processed_items, &(not is_nil(&1))) do
	{:ok, Map.put(history, "orderedItems", processed_items)}
	else
	{:error, :invalid_history}
	end
	end

	defp for_each_history_item(nil, _object, _fun) do
	{:ok, nil}
	end

	defp for_each_history_item(_, _object, _fun) do
	{:error, :invalid_history}
	end

	# fun is (object -> {:ok, validated_object_with_string_keys})
	defp do_separate_with_history(object, fun) do
	with history <- object["formerRepresentations"],
	object <- Map.drop(object, ["formerRepresentations"]),
	{_, {:ok, object}} <- {:main_body, fun.(object)},
	{_, {:ok, history}} <- {:history_items, for_each_history_item(history, object, fun)} do
	object =
	if history do
	Map.put(object, "formerRepresentations", history)
	else
	object
	end

	{:ok, object}
	else
	{:main_body, e} -> e
	{:history_items, e} -> e
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	index 844ad2c8f..1d6e0abfb 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	@@ -1,230 +1,252 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI.Utils

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	quote do
	unquote do
	import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	message_fields()
	object_fields()
	status_object_fields()
	end
	end

	field(:replies, {:array, ObjectValidators.ObjectID}, default: [])
	field(:source, :map)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data()
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_url(%{"url" => url} = data) when is_bitstring(url), do: data
	- defp fix_url(%{"url" => url} = data) when is_map(url), do: Map.put(data, "url", url["href"])
	+
	+ defp fix_url(%{"url" => url} = data) when is_map(url) do
	+ if is_binary(url["href"]) do
	+ Map.put(data, "url", url["href"])
	+ else
	+ Map.delete(data, "url")
	+ end
	+ end
	+
	+ defp fix_url(%{"url" => url} = data) when is_list(url) do
	+ first_element = Enum.at(url, 0)
	+
	+ url_string =
	+ cond do
	+ is_bitstring(first_element) -> first_element
	+ is_map(first_element) -> first_element["href"]
	+ true -> nil
	+ end
	+
	+ if is_binary(url_string) do
	+ Map.put(data, "url", url_string)
	+ else
	+ Map.delete(data, "url")
	+ end
	+ end
	+
	defp fix_url(data), do: data

	defp fix_tag(%{"tag" => tag} = data) when is_list(tag) do
	Map.put(data, "tag", Enum.filter(tag, &is_map/1))
	end

	defp fix_tag(%{"tag" => tag} = data) when is_map(tag), do: Map.put(data, "tag", [tag])
	defp fix_tag(data), do: Map.drop(data, ["tag"])

	# legacy internal *oma format
	defp fix_replies(%{"replies" => replies} = data) when is_list(replies), do: data

	defp fix_replies(%{"replies" => %{"first" => %{"items" => replies}}} = data)
	when is_list(replies),
	do: Map.put(data, "replies", replies)

	defp fix_replies(%{"replies" => %{"first" => %{"orderedItems" => replies}}} = data)
	when is_list(replies),
	do: Map.put(data, "replies", replies)

	defp fix_replies(%{"replies" => %{"items" => replies}} = data) when is_list(replies),
	do: Map.put(data, "replies", replies)

	defp fix_replies(%{"replies" => %{"orderedItems" => replies}} = data) when is_list(replies),
	do: Map.put(data, "replies", replies)

	defp fix_replies(data), do: Map.delete(data, "replies")

	- def fix_attachments(%{"attachment" => attachment} = data) when is_map(attachment),
	- do: Map.put(data, "attachment", [attachment])
	-
	- def fix_attachments(data), do: data
	+ def fix_attachments(data), do: Transmogrifier.fix_attachments(data)

	defp remote_mention_resolver(
	%{"id" => ap_id, "tag" => tags},
	"@" <> nickname = mention,
	buffer,
	opts,
	acc
	)
	when is_binary(ap_id) and is_list(tags) do
	initial_host =
	ap_id
	\|> URI.parse()
	\|> Map.get(:host)

	with mention_tag when not is_nil(mention_tag) <-
	Enum.find(tags, &mention_tag?(&1, mention, initial_host)),
	href when is_binary(href) <- mention_tag["href"],
	%User{} = user <- User.get_cached_by_ap_id(href) do
	link = Pleroma.Formatter.mention_from_user(user, opts)
	{link, %{acc \| mentions: MapSet.put(acc.mentions, {"@" <> nickname, user})}}
	else
	_ -> {buffer, acc}
	end
	end

	defp remote_mention_resolver(_object, _mention, buffer, _opts, acc), do: {buffer, acc}

	defp mention_tag?(%{"type" => "Mention", "name" => name}, mention, initial_host)
	when is_binary(name) do
	name == mention \|\| mention == "#{name}@#{initial_host}"
	end

	defp mention_tag?(_tag, _mention, _initial_host), do: false

	defp scrub_content(%{"content" => content} = object) when is_binary(content) do
	Map.put(object, "content", HTML.filter_tags(content))
	end

	defp scrub_content(object), do: object

	defp mfm_parse_limit do
	min(Pleroma.Config.get([:instance, :limit]), Pleroma.Config.get([:instance, :remote_limit]))
	end

	defp normalize_source(%{"source" => source} = object) when is_binary(source) do
	object
	\|> Map.put("source", %{"content" => source})
	\|> normalize_source()
	end

	defp normalize_source(%{"source" => source} = object) when is_map(source) do
	source =
	case source["content"] do
	content when is_binary(content) ->
	if String.length(content) <= mfm_parse_limit() do
	source
	else
	Map.delete(source, "content")
	end

	nil ->
	source

	_ ->
	Map.delete(source, "content")
	end

	Map.put(object, "source", source)
	end

	defp normalize_source(object), do: object

	defp fix_misskey_content(%{"htmlMfm" => true, "content" => content} = object)
	when is_binary(content) do
	Map.put(object, "content", HTML.filter_tags(content))
	end

	defp fix_misskey_content(%{"htmlMfm" => true} = object), do: object

	defp fix_misskey_content(
	%{"source" => %{"mediaType" => "text/x.misskeymarkdown", "content" => content}} = object
	)
	when is_binary(content) do
	mention_handler = fn nick, buffer, opts, acc ->
	remote_mention_resolver(object, nick, buffer, opts, acc)
	end

	{linked, _mentions, _tags} =
	Utils.format_input(content, "text/x.misskeymarkdown", mention_handler: mention_handler)

	Map.put(object, "content", linked)
	end

	defp fix_misskey_content(%{"source" => %{"mediaType" => "text/x.misskeymarkdown"}} = object),
	do: scrub_content(object)

	defp fix_misskey_content(%{"_misskey_content" => content} = object) when is_binary(content) do
	object
	\|> Map.put("source", %{
	"content" => content,
	"mediaType" => "text/x.misskeymarkdown"
	})
	\|> Map.delete("_misskey_content")
	\|> fix_misskey_content()
	end

	defp fix_misskey_content(object), do: object

	defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> fix_url()
	\|> fix_tag()
	\|> fix_replies()
	\|> fix_attachments()
	\|> normalize_source()
	\|> fix_misskey_content()
	\|> CommonFixes.fix_quote_url()
	\|> CommonFixes.fix_likes()
	\|> Transmogrifier.fix_emoji()
	\|> Transmogrifier.fix_content_map()
	\|> CommonFixes.maybe_add_language()
	\|> CommonFixes.maybe_add_content_map()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment, :tag])
	\|> cast_embed(:attachment)
	\|> cast_embed(:tag)
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Article", "Note", "Page"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex b/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	index 2e0f7a8a0..c5defd6f4 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	@@ -1,220 +1,262 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Language.LanguageDetector
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.EctoType.ActivityPub.ObjectValidators.LanguageCode,
	only: [good_locale_code?: 1]

	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	require Pleroma.Constants

	def cast_and_filter_recipients(message, field, follower_collection, field_fallback \\ []) do
	# Fix as:Public/Public before ObjectID casting drops it, but keep `field_fallback`
	# semantics (only used when the field is missing).
	recipients =
	%{field => message[field] \|\| field_fallback}
	\|> Transmogrifier.fix_addressing_list(field)
	\|> Transmogrifier.fix_addressing_public(field)
	\|> Map.fetch!(field)

	{:ok, data} = ObjectValidators.Recipients.cast(recipients)

	data =
	Enum.reject(data, fn x ->
	String.ends_with?(x, "/followers") and x != follower_collection
	end)

	Map.put(message, field, data)
	end

	def fix_object_defaults(data) do
	data = Maps.filter_empty_values(data)

	+ in_reply_to_id = in_reply_to_id(data["inReplyTo"])
	+
	context =
	Utils.maybe_create_context(
	- data["context"] \|\| data["conversation"] \|\| data["inReplyTo"] \|\| data["id"]
	+ data["context"] \|\| data["conversation"] \|\| in_reply_to_id \|\| data["id"]
	)

	- %User{follower_address: follower_collection} = User.get_cached_by_ap_id(data["attributedTo"])
	+ data = Map.put(data, "context", context)

	- data
	- \|> Map.put("context", context)
	- \|> cast_and_filter_recipients("to", follower_collection)
	- \|> cast_and_filter_recipients("cc", follower_collection)
	- \|> cast_and_filter_recipients("bto", follower_collection)
	- \|> cast_and_filter_recipients("bcc", follower_collection)
	- \|> Transmogrifier.fix_implicit_addressing(follower_collection)
	+ with attributed_to when is_binary(attributed_to) <- data["attributedTo"],
	+ %User{follower_address: follower_collection} <- User.get_cached_by_ap_id(attributed_to) do
	+ data
	+ \|> cast_and_filter_recipients("to", follower_collection)
	+ \|> cast_and_filter_recipients("cc", follower_collection)
	+ \|> cast_and_filter_recipients("bto", follower_collection)
	+ \|> cast_and_filter_recipients("bcc", follower_collection)
	+ \|> Transmogrifier.fix_implicit_addressing(follower_collection)
	+ else
	+ _ -> data
	+ end
	end

	+ defp in_reply_to_id(in_reply_to) when is_binary(in_reply_to), do: in_reply_to
	+ defp in_reply_to_id(%{"id" => in_reply_to}) when is_binary(in_reply_to), do: in_reply_to
	+ defp in_reply_to_id(%{"href" => in_reply_to}) when is_binary(in_reply_to), do: in_reply_to
	+ defp in_reply_to_id([in_reply_to \| _]), do: in_reply_to_id(in_reply_to)
	+ defp in_reply_to_id(_), do: nil
	+
	def fix_activity_addressing(activity) do
	%User{follower_address: follower_collection} = User.get_cached_by_ap_id(activity["actor"])

	activity
	\|> cast_and_filter_recipients("to", follower_collection)
	\|> cast_and_filter_recipients("cc", follower_collection)
	\|> cast_and_filter_recipients("bto", follower_collection)
	\|> cast_and_filter_recipients("bcc", follower_collection)
	\|> Transmogrifier.fix_implicit_addressing(follower_collection)
	end

	def fix_actor(data) do
	actor =
	data
	\|> Map.put_new("actor", data["attributedTo"])
	\|> Containment.get_actor()

	data
	\|> Map.put("actor", actor)
	\|> Map.put("attributedTo", actor)
	end

	+ def maybe_set_attributed_to_from_activity(object, activity) when is_map(object) do
	+ if is_nil(object["attributedTo"]) and is_nil(object["actor"]) do
	+ case Containment.get_actor(activity) do
	+ actor when is_binary(actor) -> Map.put(object, "attributedTo", actor)
	+ _ -> object
	+ end
	+ else
	+ object
	+ end
	+ end
	+
	def fix_activity_context(data, %Object{data: %{"context" => object_context}}) do
	data
	\|> Map.put("context", object_context)
	end

	def fix_object_action_recipients(%{"actor" => actor} = data, %Object{data: %{"actor" => actor}}) do
	to = ((data["to"] \|\| []) -- [actor]) \|> Enum.uniq()

	Map.put(data, "to", to)
	end

	def fix_object_action_recipients(data, %Object{data: %{"actor" => actor}}) do
	to = ((data["to"] \|\| []) ++ [actor]) \|> Enum.uniq()

	Map.put(data, "to", to)
	end

	- def fix_quote_url(%{"quoteUrl" => _quote_url} = data), do: data
	+ def fix_quote_url(%{"quoteUrl" => quote_url} = data) do
	+ case normalize_object_id(quote_url) do
	+ quote_url when is_binary(quote_url) -> Map.put(data, "quoteUrl", quote_url)
	+ _ -> Map.delete(data, "quoteUrl")
	+ end
	+ end

	# Fedibird
	# https://github.com/fedibird/mastodon/commit/dbd7ae6cf58a92ec67c512296b4daaea0d01e6ac
	def fix_quote_url(%{"quoteUri" => quote_url} = data) do
	- Map.put(data, "quoteUrl", quote_url)
	+ case normalize_object_id(quote_url) do
	+ quote_url when is_binary(quote_url) -> Map.put(data, "quoteUrl", quote_url)
	+ _ -> data
	+ end
	end

	# Old Fedibird (bug)
	# https://github.com/fedibird/mastodon/issues/9
	def fix_quote_url(%{"quoteURL" => quote_url} = data) do
	- Map.put(data, "quoteUrl", quote_url)
	+ case normalize_object_id(quote_url) do
	+ quote_url when is_binary(quote_url) -> Map.put(data, "quoteUrl", quote_url)
	+ _ -> data
	+ end
	end

	# Misskey fallback
	def fix_quote_url(%{"_misskey_quote" => quote_url} = data) do
	- Map.put(data, "quoteUrl", quote_url)
	+ case normalize_object_id(quote_url) do
	+ quote_url when is_binary(quote_url) -> Map.put(data, "quoteUrl", quote_url)
	+ _ -> data
	+ end
	end

	def fix_quote_url(%{"tag" => [_ \| _] = tags} = data) do
	tag = Enum.find(tags, &object_link_tag?/1)

	if not is_nil(tag) do
	data
	\|> Map.put("quoteUrl", tag["href"])
	else
	data
	end
	end

	def fix_quote_url(data), do: data

	+ defp normalize_object_id(object_id) when is_binary(object_id), do: object_id
	+ defp normalize_object_id(%{"id" => object_id}) when is_binary(object_id), do: object_id
	+ defp normalize_object_id([object_id \| _]) when is_binary(object_id), do: object_id
	+ defp normalize_object_id(_), do: nil
	+
	# On Mastodon, `"likes"` attribute includes an inlined `Collection` with `totalItems`,
	# not a list of users.
	# https://github.com/mastodon/mastodon/pull/32007
	def fix_likes(%{"likes" => %{}} = data), do: Map.drop(data, ["likes"])

	def fix_likes(data), do: data

	# https://codeberg.org/fediverse/fep/src/branch/main/fep/e232/fep-e232.md
	def object_link_tag?(%{
	"type" => "Link",
	"mediaType" => media_type,
	"href" => href
	})
	when media_type in Pleroma.Constants.activity_json_mime_types() and is_binary(href) do
	true
	end

	def object_link_tag?(_), do: false

	def maybe_add_language_from_activity(object, activity) do
	language = get_language_from_context(activity)

	if language do
	Map.put(object, "language", language)
	else
	object
	end
	end

	def maybe_add_language(object) do
	language =
	[
	&get_language_from_context/1,
	&get_language_from_content_map/1,
	&get_language_from_content/1
	]
	\|> Enum.find_value(fn get_language ->
	language = get_language.(object)

	if good_locale_code?(language) do
	language
	else
	nil
	end
	end)

	if language do
	Map.put(object, "language", language)
	else
	object
	end
	end

	defp get_language_from_context(%{"@context" => context}) when is_list(context) do
	case context
	\|> Enum.find(fn
	%{"@language" => language} -> language != "und"
	_ -> nil
	end) do
	%{"@language" => language} -> language
	_ -> nil
	end
	end

	defp get_language_from_context(_), do: nil

	defp get_language_from_content_map(%{"contentMap" => content_map, "content" => source_content}) do
	content_groups = Map.to_list(content_map)

	case Enum.find(content_groups, fn {_, content} -> content == source_content end) do
	{language, _} -> language
	_ -> nil
	end
	end

	defp get_language_from_content_map(_), do: nil

	defp get_language_from_content(%{"content" => content} = object) do
	LanguageDetector.detect("#{object["summary"] \|\| ""} #{content}")
	end

	defp get_language_from_content(_), do: nil

	def maybe_add_content_map(%{"language" => language, "content" => content} = object)
	when not_empty_string(language) do
	Map.put(object, "contentMap", Map.put(%{}, language, content))
	end

	def maybe_add_content_map(object), do: object
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/tag_validator.ex b/lib/pleroma/web/activity_pub/object_validators/tag_validator.ex
	index dc2770189..0659c93d7 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/tag_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/tag_validator.ex
	@@ -1,89 +1,188 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.TagValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators

	import Ecto.Changeset

	require Pleroma.Constants

	@primary_key false
	+ @tag_types ~w[Mention Hashtag Emoji Link]
	+
	embedded_schema do
	# Common
	field(:type, :string)
	field(:name, :string)

	# Mention, Hashtag, Link
	field(:href, ObjectValidators.Uri)

	# Link
	field(:mediaType, :string)

	# Emoji
	embeds_one :icon, IconObjectValidator, primary_key: false do
	field(:type, :string)
	field(:url, ObjectValidators.Uri)
	end

	field(:updated, ObjectValidators.DateTime)
	field(:id, ObjectValidators.Uri)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, %{"type" => "Mention"} = data) do
	struct
	\|> cast(data, [:type, :name, :href])
	\|> validate_required([:type, :href])
	end

	- def changeset(struct, %{"type" => "Hashtag", "name" => name} = data) do
	+ def changeset(struct, %{"type" => "Hashtag", "name" => name} = data) when is_binary(name) do
	name = String.downcase(name)
	data = Map.put(data, "name", name)

	struct
	\|> cast(data, [:type, :name, :href])
	\|> validate_required([:type, :name])
	end

	- def changeset(struct, %{"type" => "Emoji"} = data) do
	- data = Map.put(data, "name", String.trim(data["name"], ":"))
	+ def changeset(struct, %{"type" => "Hashtag"} = data) do
	+ struct
	+ \|> cast(data, [])
	+ \|> Map.put(:action, :ignore)
	+ end

	+ def changeset(struct, %{"type" => "Emoji", "name" => name} = data) when is_binary(name) do
	+ data =
	+ data
	+ \|> Map.put("name", String.trim(data["name"], ":"))
	+ \|> normalize_emoji_icon()
	+
	+ case data["icon"] do
	+ %{"url" => url} when is_binary(url) ->
	+ if valid_http_url?(url) do
	+ struct
	+ \|> cast(data, [:type, :name, :updated, :id])
	+ \|> cast_embed(:icon, with: &icon_changeset/2)
	+ \|> validate_required([:type, :name, :icon])
	+ else
	+ struct
	+ \|> cast(data, [])
	+ \|> Map.put(:action, :ignore)
	+ end
	+
	+ _ ->
	+ struct
	+ \|> cast(data, [])
	+ \|> Map.put(:action, :ignore)
	+ end
	+ end
	+
	+ def changeset(struct, %{"type" => "Emoji"} = data) do
	struct
	- \|> cast(data, [:type, :name, :updated, :id])
	- \|> cast_embed(:icon, with: &icon_changeset/2)
	- \|> validate_required([:type, :name, :icon])
	+ \|> cast(data, [])
	+ \|> Map.put(:action, :ignore)
	end

	def changeset(struct, %{"type" => "Link"} = data) do
	struct
	\|> cast(data, [:type, :name, :mediaType, :href])
	\|> validate_inclusion(:mediaType, Pleroma.Constants.activity_json_mime_types())
	\|> validate_required([:type, :href, :mediaType])
	end

	+ def changeset(struct, %{"type" => types} = data) when is_list(types) do
	+ changeset(struct, infer_type(data))
	+ end
	+
	def changeset(struct, %{"type" => _} = data) do
	struct
	\|> cast(data, [])
	\|> Map.put(:action, :ignore)
	end

	+ def changeset(struct, data) when is_map(data) do
	+ data = normalize(data)
	+
	+ if Map.has_key?(data, "type") do
	+ changeset(struct, data)
	+ else
	+ struct
	+ \|> cast(data, [])
	+ \|> Map.put(:action, :ignore)
	+ end
	+ end
	+
	+ def normalize(data) when is_map(data), do: infer_type(data)
	+
	+ defp infer_type(%{"type" => types} = data) when is_list(types) do
	+ type = Enum.find(types, &(&1 in @tag_types)) \|\| Enum.find(types, &is_binary/1)
	+
	+ if type, do: Map.put(data, "type", type), else: Map.delete(data, "type")
	+ end
	+
	+ defp infer_type(%{"type" => _} = data), do: data
	+ defp infer_type(%{"name" => "#" <> _} = data), do: Map.put(data, "type", "Hashtag")
	+ defp infer_type(%{"name" => "@" <> _} = data), do: Map.put(data, "type", "Mention")
	+
	+ defp infer_type(%{"mediaType" => _media_type, "href" => _href} = data),
	+ do: Map.put(data, "type", "Link")
	+
	+ defp infer_type(data), do: data
	+
	+ defp normalize_emoji_icon(%{"icon" => icon} = data) when is_binary(icon) do
	+ Map.put(data, "icon", %{"type" => "Image", "url" => icon})
	+ end
	+
	+ defp normalize_emoji_icon(%{"icon" => icon} = data) when is_map(icon) do
	+ case extract_icon_url(icon) do
	+ url when is_binary(url) -> Map.put(data, "icon", %{"type" => "Image", "url" => url})
	+ _ -> Map.delete(data, "icon")
	+ end
	+ end
	+
	+ defp normalize_emoji_icon(data), do: data
	+
	+ defp extract_icon_url(%{"url" => url}) when is_binary(url), do: url
	+
	+ defp extract_icon_url(%{"url" => %{"href" => href}}) when is_binary(href), do: href
	+
	+ defp extract_icon_url(%{"url" => [first \| _]}) do
	+ cond do
	+ is_binary(first) -> first
	+ is_map(first) -> first["href"]
	+ true -> nil
	+ end
	+ end
	+
	+ defp extract_icon_url(%{"href" => href}) when is_binary(href), do: href
	+
	+ defp extract_icon_url(_), do: nil
	+
	+ defp valid_http_url?(url) when is_binary(url) do
	+ match?({:ok, _}, ObjectValidators.Uri.cast(url))
	+ end
	+
	+ defp valid_http_url?(_), do: false
	+
	def icon_changeset(struct, data) do
	struct
	\|> cast(data, [:type, :url])
	\|> validate_inclusion(:type, ~w[Image])
	\|> validate_required([:type, :url])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index a013dd226..33ab62ca3 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1096 +1,1207 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	@behaviour Pleroma.Web.ActivityPub.Transmogrifier.API
	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Emoji
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator

	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	require Pleroma.Constants

	+ @supported_types Pleroma.Constants.activity_types() ++
	+ Pleroma.Constants.object_types() ++ Pleroma.Constants.actor_types()
	+
	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object, options \\ []) do
	object
	\|> strip_internal_fields()
	\|> fix_actor()
	\|> fix_url()
	\|> fix_attachments()
	\|> fix_context()
	\|> fix_in_reply_to(options)
	\|> fix_emoji()
	\|> fix_tag()
	\|> fix_content_map()
	\|> fix_addressing()
	\|> fix_summary()
	\|> fix_history(&fix_object/1)
	end

	defp maybe_fix_object(%{"attributedTo" => _} = object), do: fix_object(object)
	defp maybe_fix_object(object), do: object

	defp fix_history(%{"formerRepresentations" => %{"orderedItems" => list}} = obj, fix_fun)
	when is_list(list) do
	update_in(obj["formerRepresentations"]["orderedItems"], fn h -> Enum.map(h, fix_fun) end)
	end

	defp fix_history(obj, _), do: obj

	defp fix_recursive(obj, fun) do
	# unlike Erlang, Elixir does not support recursive inline functions
	# which would allow us to avoid reconstructing this on every recursion
	rec_fun = fn
	obj when is_map(obj) -> fix_recursive(obj, fun)
	# there may be simple AP IDs in history (or object field)
	obj -> obj
	end

	obj
	\|> fun.()
	\|> fix_history(rec_fun)
	\|> then(fn
	%{"object" => object} = doc when is_map(object) ->
	update_in(doc["object"], rec_fun)

	apdoc ->
	apdoc
	end)
	end

	def fix_summary(%{"summary" => nil} = object) do
	Map.put(object, "summary", "")
	end

	def fix_summary(%{"summary" => _} = object) do
	# summary is present, nothing to do
	object
	end

	def fix_summary(object), do: Map.put(object, "summary", "")

	def fix_addressing_list(map, field) do
	addrs = map[field]

	cond do
	is_list(addrs) ->
	Map.put(map, field, Enum.filter(addrs, &is_binary/1))

	is_binary(addrs) ->
	Map.put(map, field, [addrs])

	true ->
	Map.put(map, field, [])
	end
	end

	@doc """
	Bovine compatibility
	https://codeberg.org/bovine/bovine/issues/53
	"""
	def fix_addressing_public(map, field) do
	addrs = Map.get(map, field, []) \|> List.wrap()

	Map.put(
	map,
	field,
	Enum.map(addrs, fn
	"Public" -> Pleroma.Constants.as_public()
	"as:Public" -> Pleroma.Constants.as_public()
	x -> x
	end)
	)
	end

	# if directMessage flag is set to true, leave the addressing alone
	def fix_explicit_addressing(%{"directMessage" => true} = object, _follower_collection),
	do: object

	def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, follower_collection) do
	explicit_mentions =
	Utils.determine_explicit_mentions(object) ++
	[Pleroma.Constants.as_public(), follower_collection]

	explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
	explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.filter(& &1)
	\|> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
	\|> Enum.uniq()

	object
	\|> Map.put("to", explicit_to)
	\|> Map.put("cc", final_cc)
	end

	# if as:Public is addressed, then make sure the followers collection is also addressed
	# so that the activities will be delivered to local users.
	def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
	recipients = to ++ cc

	if followers_collection not in recipients do
	cond do
	Pleroma.Constants.as_public() in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	Pleroma.Constants.as_public() in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_addressing(object) do
	{:ok, %User{follower_address: follower_collection}} =
	object
	\|> Containment.get_actor()
	\|> User.get_or_fetch_by_ap_id()

	object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	\|> fix_addressing_public("to")
	\|> fix_addressing_public("cc")
	\|> fix_addressing_public("bto")
	\|> fix_addressing_public("bcc")
	\|> fix_explicit_addressing(follower_collection)
	\|> fix_implicit_addressing(follower_collection)
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	actor = Containment.get_actor(%{"actor" => actor})

	# TODO: Remove actor field for Objects
	object
	\|> Map.put("actor", actor)
	\|> Map.put("attributedTo", actor)
	end

	def fix_in_reply_to(object, options \\ [])

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
	when not is_nil(in_reply_to) do
	in_reply_to_id = prepare_in_reply_to(in_reply_to)
	+
	+ object =
	+ cond do
	+ is_list(in_reply_to) ->
	+ if not_empty_string(in_reply_to_id) do
	+ Map.put(object, "inReplyTo", in_reply_to_id)
	+ else
	+ Map.delete(object, "inReplyTo")
	+ end
	+
	+ is_map(in_reply_to) and is_nil(in_reply_to["id"]) and is_binary(in_reply_to["href"]) ->
	+ Map.put(object, "inReplyTo", in_reply_to["href"])
	+
	+ is_map(in_reply_to) and is_nil(in_reply_to["id"]) and is_nil(in_reply_to["href"]) ->
	+ Map.delete(object, "inReplyTo")
	+
	+ true ->
	+ object
	+ end
	+
	depth = (options[:depth] \|\| 0) + 1

	- if Federator.allowed_thread_distance?(depth) do
	+ if not_empty_string(in_reply_to_id) and Federator.allowed_thread_distance?(depth) do
	with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.drop(["conversation", "inReplyToAtomUri"])
	else
	_ ->
	object
	end
	else
	object
	end
	end

	def fix_in_reply_to(object, _options), do: object

	def fix_quote_url_and_maybe_fetch(object, options \\ []) do
	quote_url =
	case CommonFixes.fix_quote_url(object) do
	%{"quoteUrl" => quote_url} -> quote_url
	_ -> nil
	end

	with {:quoting?, true} <- {:quoting?, not is_nil(quote_url)},
	{:ok, quoted_object} <- get_obj_helper(quote_url, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(quoted_object.data["id"]) do
	Map.put(object, "quoteUrl", quoted_object.data["id"])
	else
	{:quoting?, _} ->
	object

	_ ->
	object
	end
	end

	defp prepare_in_reply_to(in_reply_to) do
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	+ is_map(in_reply_to) && is_bitstring(in_reply_to["href"]) ->
	+ in_reply_to["href"]
	+
	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	+ is_list(in_reply_to) && is_map(Enum.at(in_reply_to, 0)) ->
	+ in_reply_to
	+ \|> Enum.at(0)
	+ \|> prepare_in_reply_to()
	+
	true ->
	""
	end
	end

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.drop(["conversation"])
	end

	- def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	- attachments =
	- Enum.map(attachment, fn data ->
	- url =
	- cond do
	- is_list(data["url"]) -> List.first(data["url"])
	- is_map(data["url"]) -> data["url"]
	- true -> nil
	- end
	-
	- media_type =
	- cond do
	- is_map(url) && url =~ Pleroma.Constants.mime_regex() ->
	- url["mediaType"]
	-
	- is_bitstring(data["mediaType"]) && data["mediaType"] =~ Pleroma.Constants.mime_regex() ->
	- data["mediaType"]
	-
	- is_bitstring(data["mimeType"]) && data["mimeType"] =~ Pleroma.Constants.mime_regex() ->
	- data["mimeType"]
	+ defp valid_http_url?(href) when is_binary(href) do
	+ match?({:ok, _}, ObjectValidators.Uri.cast(href))
	+ end

	- true ->
	- nil
	- end
	+ defp valid_http_url?(_), do: false

	- href =
	- cond do
	- is_map(url) && is_binary(url["href"]) -> url["href"]
	- is_binary(data["url"]) -> data["url"]
	- is_binary(data["href"]) -> data["href"]
	- true -> nil
	- end
	+ def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	+ attachments =
	+ Enum.map(attachment, fn
	+ data when is_map(data) ->
	+ url =
	+ cond do
	+ is_list(data["url"]) -> List.first(data["url"])
	+ is_map(data["url"]) -> data["url"]
	+ true -> nil
	+ end
	+
	+ url_data = if is_map(url), do: url, else: %{}
	+
	+ media_type =
	+ cond do
	+ is_bitstring(url_data["mediaType"]) &&
	+ url_data["mediaType"] =~ Pleroma.Constants.mime_regex() ->
	+ url_data["mediaType"]
	+
	+ is_bitstring(data["mediaType"]) &&
	+ data["mediaType"] =~ Pleroma.Constants.mime_regex() ->
	+ data["mediaType"]
	+
	+ is_bitstring(data["mimeType"]) && data["mimeType"] =~ Pleroma.Constants.mime_regex() ->
	+ data["mimeType"]
	+
	+ true ->
	+ nil
	+ end
	+
	+ href =
	+ cond do
	+ is_binary(url) -> url
	+ is_binary(url_data["href"]) -> url_data["href"]
	+ is_binary(data["url"]) -> data["url"]
	+ is_binary(data["href"]) -> data["href"]
	+ true -> nil
	+ end
	+
	+ if href && valid_http_url?(href) do
	+ attachment_url =
	+ %{
	+ "href" => href,
	+ "type" => Map.get(url_data, "type", "Link")
	+ }
	+ \|> Maps.put_if_present("mediaType", media_type)
	+ \|> Maps.put_if_present("width", url_data["width"] \|\| data["width"])
	+ \|> Maps.put_if_present("height", url_data["height"] \|\| data["height"])

	- if href do
	- attachment_url =
	%{
	- "href" => href,
	- "type" => Map.get(url \|\| %{}, "type", "Link")
	+ "url" => [attachment_url],
	+ "type" => data["type"] \|\| "Document"
	}
	\|> Maps.put_if_present("mediaType", media_type)
	- \|> Maps.put_if_present("width", (url \|\| %{})["width"] \|\| data["width"])
	- \|> Maps.put_if_present("height", (url \|\| %{})["height"] \|\| data["height"])
	+ \|> Maps.put_if_present("name", data["name"])
	+ \|> Maps.put_if_present("blurhash", data["blurhash"])
	+ else
	+ nil
	+ end

	- %{
	- "url" => [attachment_url],
	- "type" => data["type"] \|\| "Document"
	- }
	- \|> Maps.put_if_present("mediaType", media_type)
	- \|> Maps.put_if_present("name", data["name"])
	- \|> Maps.put_if_present("blurhash", data["blurhash"])
	- else
	+ _ ->
	nil
	- end
	end)
	\|> Enum.filter(& &1)

	Map.put(object, "attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	object
	\|> Map.put("attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	Map.put(object, "url", url["href"])
	end

	def fix_url(%{"url" => url} = object) when is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	Map.put(object, "url", url_string)
	end

	def fix_url(object), do: object

	+ defp emoji_icon_url(icon) when is_binary(icon), do: icon
	+
	+ defp emoji_icon_url(%{"url" => url}) when is_binary(url), do: url
	+
	+ defp emoji_icon_url(%{"url" => %{"href" => href}}) when is_binary(href), do: href
	+
	+ defp emoji_icon_url(%{"url" => [first \| _]}) do
	+ cond do
	+ is_binary(first) -> first
	+ is_map(first) -> first["href"] \|\| first["url"] \|\| first["id"]
	+ true -> nil
	+ end
	+ end
	+
	+ defp emoji_icon_url(%{"href" => href}) when is_binary(href), do: href
	+
	+ defp emoji_icon_url(_), do: nil
	+
	+ defp valid_emoji_icon_url(icon) do
	+ case emoji_icon_url(icon) do
	+ url when is_binary(url) -> if valid_http_url?(url), do: url
	+ _ -> nil
	+ end
	+ end
	+
	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji =
	tags
	- \|> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
	+ \|> Enum.filter(fn data ->
	+ is_map(data) and data["type"] == "Emoji" and is_binary(data["name"]) and data["icon"]
	+ end)
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	- Map.put(mapping, name, data["icon"]["url"])
	+ case valid_emoji_icon_url(data["icon"]) do
	+ url when is_binary(url) -> Map.put(mapping, name, url)
	+ _ -> mapping
	+ end
	end)

	Map.put(object, "emoji", emoji)
	end

	- def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	- name = String.trim(tag["name"], ":")
	- emoji = %{name => tag["icon"]["url"]}
	+ def fix_emoji(%{"tag" => %{"type" => "Emoji", "name" => name} = tag} = object)
	+ when is_binary(name) do
	+ name = String.trim(name, ":")

	- Map.put(object, "emoji", emoji)
	+ with url when is_binary(url) <- valid_emoji_icon_url(tag["icon"]) do
	+ Map.put(object, "emoji", %{name => url})
	+ else
	+ _ -> object
	+ end
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	- \|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	+ \|> Enum.filter(fn data ->
	+ is_map(data) and data["type"] == "Hashtag" and is_binary(data["name"])
	+ end)
	\|> Enum.map(fn
	%{"name" => "#" <> hashtag} -> String.downcase(hashtag)
	%{"name" => hashtag} -> String.downcase(hashtag)
	end)

	Map.put(object, "tag", tag ++ tags)
	end

	def fix_tag(%{"tag" => %{} = tag} = object) do
	object
	\|> Map.put("tag", [tag])
	\|> fix_tag
	end

	def fix_tag(object), do: object

	# prefer content over contentMap
	def fix_content_map(%{"content" => content} = object) when not_empty_string(content), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	Map.put(object, "content", content)
	end

	def fix_content_map(object), do: object

	defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
	when is_binary(reply_id) do
	options = Keyword.put(options, :fetch, true)

	with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
	Map.put(object, "type", "Answer")
	else
	_ -> object
	end
	end

	defp fix_type(object, _options), do: object

	# Reduce the object list to find the reported user.
	defp get_reported(objects) do
	Enum.reduce_while(objects, nil, fn ap_id, _ ->
	with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
	{:halt, user}
	else
	_ -> {:cont, nil}
	end
	end)
	end

	defp reject_third_party_report(%User{local: false}, %User{local: false} = account) do
	{:reject, "[Transmogrifier] third-party report: #{account.ap_id}"}
	end

	defp reject_third_party_report(_, _), do: :ok

	def handle_incoming(data, options \\ []) do
	data
	\|> fix_recursive(&strip_internal_fields/1)
	+ \|> fix_recursive(&fix_type_as_string/1)
	\|> handle_incoming_normalized(options)
	end

	+ defp fix_type_as_string(data) do
	+ data
	+ \|> normalize_type()
	+ \|> normalize_tag_types()
	+ end
	+
	+ defp normalize_type(%{"type" => types} = data) when is_list(types) do
	+ type = Enum.find(types, &(&1 in @supported_types)) \|\| Enum.find(types, &is_binary/1)
	+
	+ if type, do: Map.put(data, "type", type), else: data
	+ end
	+
	+ defp normalize_type(data), do: data
	+
	+ defp normalize_tag_types(%{"tag" => tags} = data) when is_list(tags) do
	+ Map.put(data, "tag", Enum.map(tags, &normalize_tag_type/1))
	+ end
	+
	+ defp normalize_tag_types(%{"tag" => tag} = data) when is_map(tag) do
	+ Map.put(data, "tag", normalize_tag_type(tag))
	+ end
	+
	+ defp normalize_tag_types(data), do: data
	+
	+ defp normalize_tag_type(tag) when is_map(tag), do: TagValidator.normalize(tag)
	+ defp normalize_tag_type(tag), do: tag
	+
	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	defp handle_incoming_normalized(
	%{"type" => "Flag", "object" => objects, "actor" => actor} = data,
	_options
	) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	objects <- List.wrap(objects),
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	# Reduce the object list to find the reported user.
	%User{} = account <- get_reported(objects),
	:ok <- reject_third_party_report(actor, account),
	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	%{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{"cc" => [account.ap_id]}
	}
	\|> ActivityPub.flag()
	end
	end

	# disallow objects with bogus IDs
	defp handle_incoming_normalized(%{"id" => nil}, _options), do: :error
	defp handle_incoming_normalized(%{"id" => ""}, _options), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	defp handle_incoming_normalized(%{"id" => id}, _options)
	when is_binary(id) and byte_size(id) < 8,
	do: :error

	defp handle_incoming_normalized(
	%{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
	options
	) do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	reply_depth = (options[:depth] \|\| 0) + 1
	options = Keyword.put(options, :depth, reply_depth)
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: nil,
	local: false,
	published: data["published"],
	additional: Map.take(data, ["cc", "id"])
	}

	ActivityPub.listen(params)
	else
	_e -> :error
	end
	end

	@misskey_reactions %{
	"like" => "👍",
	"love" => "❤️",
	"laugh" => "😆",
	"hmm" => "🤔",
	"surprise" => "😮",
	"congrats" => "🎉",
	"angry" => "💢",
	"confused" => "😥",
	"rip" => "😇",
	"pudding" => "🍮",
	"star" => "⭐"
	}

	# Rewrite misskey likes into EmojiReacts
	defp handle_incoming_normalized(
	%{
	"type" => "Like",
	"content" => content
	} = data,
	options
	)
	when is_binary(content) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(
	%{
	"type" => "Like",
	"_misskey_reaction" => reaction
	} = data,
	options
	) do
	data
	\|> Map.put("content", @misskey_reactions[reaction] \|\| reaction)
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(
	%{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
	options
	)
	when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note Page Image} do
	fetch_options = Keyword.put(options, :depth, (options[:depth] \|\| 0) + 1)

	object =
	data["object"]
	\|> strip_internal_fields()
	\|> fix_type(fetch_options)
	\|> fix_in_reply_to(fetch_options)
	\|> fix_quote_url_and_maybe_fetch(fetch_options)

	data = Map.put(data, "object", object)
	options = Keyword.put(options, :local, false)

	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	nil <- Activity.get_create_by_object_ap_id(obj_id),
	{:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
	{:ok, activity}
	else
	%Activity{} = activity -> {:ok, activity}
	e -> e
	end
	end

	defp handle_incoming_normalized(%{"type" => type} = data, _options)
	when type in ~w{Like EmojiReact Announce Add Remove} do
	with :ok <- ObjectValidator.fetch_actor_and_object(data),
	{:ok, activity, _meta} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	e -> {:error, e}
	end
	end

	defp handle_incoming_normalized(
	%{"type" => type} = data,
	_options
	)
	when type in ~w{Update Block Follow Accept Reject} do
	fixed_obj = maybe_fix_object(data["object"])
	data = if fixed_obj != nil, do: %{data \| "object" => fixed_obj}, else: data

	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	{:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	defp handle_incoming_normalized(
	%{"type" => "Delete"} = data,
	_options
	) do
	with {:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	{:error, {:validate, _}} = e ->
	# Check if we have a create activity for this
	with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
	%Activity{data: %{"actor" => actor}} <-
	Activity.create_by_object_ap_id(object_id) \|> Repo.one(),
	# We have one, insert a tombstone and retry
	{:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	handle_incoming(data)
	else
	_ -> e
	end

	e ->
	{:error, e}
	end
	end

	defp handle_incoming_normalized(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data,
	_options
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	{:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	defp handle_incoming_normalized(
	%{
	"type" => "Undo",
	"object" => %{"type" => type}
	} = data,
	_options
	)
	when type in ["Like", "EmojiReact", "Announce", "Block"] do
	with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	# For Undos that don't have the complete object attached, try to find it in our database.
	defp handle_incoming_normalized(
	%{
	"type" => "Undo",
	"object" => object
	} = activity,
	options
	)
	when is_binary(object) do
	with %Activity{data: data} <- Activity.get_by_ap_id(object) do
	activity
	\|> Map.put("object", data)
	\|> handle_incoming_normalized(options)
	else
	_e -> :error
	end
	end

	defp handle_incoming_normalized(
	%{
	"type" => "Move",
	"actor" => origin_actor,
	"object" => origin_actor,
	"target" => target_actor
	},
	_options
	) do
	with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
	true <- origin_actor in target_user.also_known_as do
	ActivityPub.move(origin_user, target_user, false)
	else
	_e -> :error
	end
	end

	# Rewrite dislikes into the thumbs down emoji
	defp handle_incoming_normalized(%{"type" => "Dislike"} = data, options) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", "👎")
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(
	%{"type" => "Undo", "object" => %{"type" => "Dislike"}} = data,
	options
	) do
	data
	\|> put_in(["object", "type"], "EmojiReact")
	\|> put_in(["object", "content"], "👎")
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(_, _), do: :error

	@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} \| nil
	def get_obj_helper(id, options \\ []) do
	options = Keyword.put(options, :fetch, true)

	case Object.normalize(id, options) do
	%Object{} = object -> {:ok, object}
	_ -> nil
	end
	end

	@spec get_embedded_obj_helper(String.t() \| Object.t(), User.t()) :: {:ok, Object.t()} \| nil
	def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
	ap_id: ap_id
	})
	when attributed_to == ap_id do
	with {:ok, activity} <-
	handle_incoming(%{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => attributed_to,
	"object" => data
	}) do
	{:ok, Object.normalize(activity, fetch: false)}
	else
	_ -> get_obj_helper(object_id)
	end
	end

	def get_embedded_obj_helper(object_id, _) do
	get_obj_helper(object_id)
	end

	def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
	with false <- String.starts_with?(in_reply_to, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| in_reply_to)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	@doc """
	Fedibird compatibility
	https://github.com/fedibird/mastodon/commit/dbd7ae6cf58a92ec67c512296b4daaea0d01e6ac
	"""
	def set_quote_url(%{"quoteUrl" => quote_url} = object) when is_binary(quote_url) do
	Map.put(object, "quoteUri", quote_url)
	end

	def set_quote_url(obj), do: obj

	@doc """
	Inline first page of the `replies` collection,
	containing any replies in chronological order.
	"""
	def set_replies(%{"type" => type} = obj_data)
	when type in Pleroma.Constants.status_object_types() do
	with obj_ap_id when is_binary(obj_ap_id) <- obj_data["id"],
	limit when limit > 0 <-
	Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
	collection <-
	Pleroma.Web.ActivityPub.ObjectView.render("object_replies.json", %{
	render_params: %{object_ap_id: obj_data["id"], limit: limit, skip_ap_ctx: true}
	}) do
	Map.put(obj_data, "replies", collection)
	else
	0 -> Map.put(obj_data, "replies", obj_data["id"] <> "/replies")
	_ -> obj_data
	end
	end

	def set_replies(obj_data), do: obj_data

	defp set_voters_count(%{"voters" => [_ \| _] = voters} = obj) do
	Map.merge(obj, %{"votersCount" => length(voters)})
	end

	defp set_voters_count(obj), do: obj

	# Prepares and sanitizes the object for federation.
	def prepare_object(object) do
	object
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> set_quote_url
	\|> set_replies
	\|> set_voters_count
	\|> CommonFixes.maybe_add_content_map()
	\|> strip_internal_fields
	\|> strip_internal_tags
	\|> set_type
	\|> maybe_process_history
	end

	defp maybe_process_history(%{"formerRepresentations" => %{"orderedItems" => history}} = object) do
	processed_history =
	Enum.map(
	history,
	fn
	item when is_map(item) -> prepare_object(item)
	item -> item
	end
	)

	put_in(object, ["formerRepresentations", "orderedItems"], processed_history)
	end

	defp maybe_process_history(object) do
	object
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	def prepare_activity(%{"type" => activity_type, "object" => object_id} = data)
	when activity_type in ["Create", "Listen"] do
	object =
	object_id
	\|> Object.normalize(fetch: false)
	\|> Map.get(:data)

	data =
	data
	\|> Map.put("object", prepare_object(object))
	\|> Map.merge(Utils.make_json_ld_header(object))
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_activity(%{"type" => "Update", "object" => %{"type" => objtype} = object} = data)
	when objtype in Pleroma.Constants.updatable_object_types() do
	data =
	data
	\|> Map.put("object", prepare_object(object))
	\|> Map.merge(Utils.make_json_ld_header(object))
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_activity(%{"type" => "Update", "object" => %{"type" => objtype} = object} = data)
	when objtype in Pleroma.Constants.actor_types() do
	object =
	object
	\|> maybe_fix_user_object()
	\|> strip_internal_fields()

	data =
	data
	\|> Map.put("object", object)
	\|> strip_internal_fields()
	\|> Map.merge(Utils.make_json_ld_header(object))
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_activity(%{"type" => "Update", "object" => %{}} = data) do
	raise "Requested to serve an Update for non-updateable object type: #{inspect(data)}"
	end

	def prepare_activity(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
	object =
	object_id
	\|> Object.normalize(fetch: false)

	data =
	if Visibility.private?(object) && object.data["actor"] == ap_id do
	data \|> Map.put("object", object \|> Map.get(:data) \|> prepare_object)
	else
	data \|> maybe_fix_object_url
	end

	data =
	data
	\|> strip_internal_fields
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_activity(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_activity(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_activity(%{"type" => "Flag"} = data) do
	with {:ok, stripped_activity} <- Utils.strip_report_status_data(data),
	stripped_activity <- Utils.maybe_anonymize_reporter(stripped_activity),
	stripped_activity <- Map.merge(stripped_activity, Utils.make_json_ld_header()) do
	{:ok, stripped_activity}
	end
	end

	def prepare_activity(%{"type" => _type} = data) do
	data =
	data
	\|> strip_internal_fields
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header(data))

	{:ok, data}
	end

	def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
	with false <- String.starts_with?(object, "http"),
	{:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
	%{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
	relative_object do
	Map.put(data, "object", external_url)
	else
	{:fetch, _} ->
	data

	_ ->
	data
	end
	end

	def maybe_fix_object_url(data), do: data

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn
	# Expand internal representation tags into AS2 tags.
	tag when is_binary(tag) ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}

	# Do not process tags which are already AS2 tag objects.
	tag when is_map(tag) ->
	tag
	end)

	Map.put(object, "tag", tags)
	end

	# TODO These should be added on our side on insertion, it doesn't make much
	# sense to regenerate these all the time
	def add_mention_tags(object) do
	to = object["to"] \|\| []
	cc = object["cc"] \|\| []
	mentioned = User.get_users_from_set(to ++ cc, local_only: false)

	mentions = Enum.map(mentioned, &build_mention_tag/1)

	tags = object["tag"] \|\| []
	Map.put(object, "tag", tags ++ mentions)
	end

	defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
	%{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
	end

	def take_emoji_tags(%User{emoji: emoji}) do
	emoji
	\|> Map.to_list()
	\|> Enum.map(&Emoji.build_emoji_tag/1)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(%{"emoji" => emoji} = object) do
	tags = object["tag"] \|\| []

	out = Enum.map(emoji, &Emoji.build_emoji_tag/1)

	Map.put(object, "tag", tags ++ out)
	end

	def add_emoji_tags(object), do: object

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_type(%{"type" => "Answer"} = object) do
	Map.put(object, "type", "Note")
	end

	def set_type(object), do: object

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]
	Map.put(object, "attributedTo", attributed_to)
	end

	# TODO: Revisit this
	def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

	def prepare_attachments(object) do
	attachments =
	object
	\|> Map.get("attachment", [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} = url \| _] = data["url"]

	%{
	"url" => href,
	"mediaType" => media_type,
	"name" => data["name"],
	"type" => "Document"
	}
	\|> Maps.put_if_present("width", url["width"])
	\|> Maps.put_if_present("height", url["height"])
	\|> Maps.put_if_present("blurhash", data["blurhash"])
	end)

	Map.put(object, "attachment", attachments)
	end

	def strip_internal_fields(object) do
	Map.drop(object, Pleroma.Constants.object_internal_fields())
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags = Enum.filter(tags, fn x -> is_map(x) end)

	Map.put(object, "tag", tags)
	end

	defp strip_internal_tags(object), do: object

	def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
	Map.put(data, "url", url["href"])
	end

	def maybe_fix_user_url(data), do: data

	def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
	end
	diff --git a/test/fixtures/fedidev.fun/attachment_embedded_note.json b/test/fixtures/fedidev.fun/attachment_embedded_note.json
	new file mode 100644
	index 000000000..8e83762dc
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/attachment_embedded_note.json
	@@ -0,0 +1,32 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/attachment-embedded-note",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:01Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-attachment-embedded-note",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:01Z",
	+ "content": "Note with embedded Note attachment",
	+ "attachment": {
	+ "type": "Note",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "name": "attached note",
	+ "content": "This is just a note",
	+ "published": "2024-03-06T07:23:56Z"
	+ }
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/attachment_payto_link.json b/test/fixtures/fedidev.fun/attachment_payto_link.json
	new file mode 100644
	index 000000000..1da324cb3
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/attachment_payto_link.json
	@@ -0,0 +1,31 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/attachment-payto-link",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:00Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-attachment-payto-link",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:00Z",
	+ "content": "Payment Link",
	+ "attachment": {
	+ "type": "Link",
	+ "name": "Donate",
	+ "href": "payto://iban/DE75512108001245126199",
	+ "rel": "payment"
	+ }
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/attachment_url_list.json b/test/fixtures/fedidev.fun/attachment_url_list.json
	new file mode 100644
	index 000000000..0efaeafdb
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/attachment_url_list.json
	@@ -0,0 +1,40 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/attachment-url-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:02Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-attachment-url-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:02Z",
	+ "content": "url is array of two Link objects",
	+ "attachment": {
	+ "type": "Image",
	+ "url": [
	+ {
	+ "type": "Link",
	+ "href": "https://fedidev.fun/images/007.png",
	+ "mediaType": "image/png"
	+ },
	+ {
	+ "type": "Link",
	+ "href": "https://fedidev.fun/images/008.jpg",
	+ "mediaType": "image/jpeg"
	+ }
	+ ]
	+ }
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/emoji_icon_string.json b/test/fixtures/fedidev.fun/emoji_icon_string.json
	new file mode 100644
	index 000000000..0be3deb8c
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/emoji_icon_string.json
	@@ -0,0 +1,32 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/emoji-icon-string",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:00Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-emoji-icon-string",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:00Z",
	+ "content": "emoji icon as string :cow:",
	+ "tag": [
	+ {
	+ "type": "Emoji",
	+ "name": ":cow:",
	+ "icon": "https://fedidev.fun/static/cow.png"
	+ }
	+ ]
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/emoji_icon_url_missing_type.json b/test/fixtures/fedidev.fun/emoji_icon_url_missing_type.json
	new file mode 100644
	index 000000000..2837872eb
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/emoji_icon_url_missing_type.json
	@@ -0,0 +1,34 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/emoji-icon-url-missing-type",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:01Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-emoji-icon-url-missing-type",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:01Z",
	+ "content": "emoji icon url missing type :cow2:",
	+ "tag": [
	+ {
	+ "type": "Emoji",
	+ "name": ":cow2:",
	+ "icon": {
	+ "url": "https://fedidev.fun/static/cow.png"
	+ }
	+ }
	+ ]
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/emoji_missing_icon.json b/test/fixtures/fedidev.fun/emoji_missing_icon.json
	new file mode 100644
	index 000000000..69af01a73
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/emoji_missing_icon.json
	@@ -0,0 +1,31 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/emoji-missing-icon",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:02Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-emoji-missing-icon",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:02Z",
	+ "content": "emoji missing icon :cow3:",
	+ "tag": [
	+ {
	+ "type": "Emoji",
	+ "name": ":cow3:"
	+ }
	+ ]
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/in_reply_to_collection.json b/test/fixtures/fedidev.fun/in_reply_to_collection.json
	new file mode 100644
	index 000000000..4deb7ed9a
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/in_reply_to_collection.json
	@@ -0,0 +1,30 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/in-reply-to-collection",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:08Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-in-reply-to-collection",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:08Z",
	+ "content": "collection",
	+ "inReplyTo": {
	+ "type": "Collection",
	+ "items": [
	+ "https://fedidev.fun/users/alice"
	+ ]
	+ }
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/in_reply_to_embedded_note.json b/test/fixtures/fedidev.fun/in_reply_to_embedded_note.json
	new file mode 100644
	index 000000000..de66f144f
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/in_reply_to_embedded_note.json
	@@ -0,0 +1,35 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/in-reply-to-embedded-note",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:21Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-in-reply-to-embedded-note",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:21Z",
	+ "content": "embedded note",
	+ "inReplyTo": {
	+ "@context": "https://www.w3.org/ns/activitystreams",
	+ "type": "Note",
	+ "id": "https://fedidev.fun/assets/note1.jsonap",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "content": "One",
	+ "published": "2024-01-06T13:11:45Z"
	+ }
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/in_reply_to_link.json b/test/fixtures/fedidev.fun/in_reply_to_link.json
	new file mode 100644
	index 000000000..f000ddcac
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/in_reply_to_link.json
	@@ -0,0 +1,28 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/in-reply-to-link",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:39:56Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-in-reply-to-link",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:39:56Z",
	+ "content": "Link in inReplyTo",
	+ "inReplyTo": {
	+ "type": "Link",
	+ "href": "https://fedidev.fun/assets/note1.jsonap"
	+ }
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/in_reply_to_list.json b/test/fixtures/fedidev.fun/in_reply_to_list.json
	new file mode 100644
	index 000000000..7242558b3
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/in_reply_to_list.json
	@@ -0,0 +1,28 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/in-reply-to-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:08Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-in-reply-to-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:40:08Z",
	+ "content": "two elements in inReplyTo",
	+ "inReplyTo": [
	+ "https://fedidev.fun/assets/note1.jsonap",
	+ "https://fedidev.fun/assets/note2.jsonap"
	+ ]
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/missing_attributed_to.json b/test/fixtures/fedidev.fun/missing_attributed_to.json
	new file mode 100644
	index 000000000..c2e644e84
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/missing_attributed_to.json
	@@ -0,0 +1,25 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/missing-attributedto",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:42:00Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-missing-attributedto",
	+ "attributedTo": null,
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:42:00Z",
	+ "content": "object without attributedTo"
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/misskey_quote_list.json b/test/fixtures/fedidev.fun/misskey_quote_list.json
	new file mode 100644
	index 000000000..b9ea08691
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/misskey_quote_list.json
	@@ -0,0 +1,28 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/misskey-quote-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:53Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-misskey-quote-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:53Z",
	+ "content": "_misskey_quote attribute as list",
	+ "_misskey_quote": [
	+ "https://fedidev.fun/assets/note1.jsonap",
	+ "https://fedidev.fun/assets/note2.jsonap"
	+ ]
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/object_type_list.json b/test/fixtures/fedidev.fun/object_type_list.json
	new file mode 100644
	index 000000000..f4ab00578
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/object_type_list.json
	@@ -0,0 +1,28 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/object-type-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:32Z",
	+ "object": {
	+ "type": [
	+ "Note"
	+ ],
	+ "id": "https://fedidev.fun/objects/note-object-type-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:32Z",
	+ "name": "name",
	+ "summary": "summary",
	+ "content": "content"
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/quote_uri_list.json b/test/fixtures/fedidev.fun/quote_uri_list.json
	new file mode 100644
	index 000000000..9245077e6
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/quote_uri_list.json
	@@ -0,0 +1,28 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/quote-uri-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:52Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-quote-uri-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:52Z",
	+ "content": "quoteUri attribute as list",
	+ "quoteUri": [
	+ "https://fedidev.fun/assets/note1.jsonap",
	+ "https://fedidev.fun/assets/note2.jsonap"
	+ ]
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/quote_url_list.json b/test/fixtures/fedidev.fun/quote_url_list.json
	new file mode 100644
	index 000000000..eecd0dd35
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/quote_url_list.json
	@@ -0,0 +1,28 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/quote-url-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:52Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-quote-url-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:43:52Z",
	+ "content": "quoteUrl attribute as list",
	+ "quoteUrl": [
	+ "https://fedidev.fun/assets/note1.jsonap",
	+ "https://fedidev.fun/assets/note2.jsonap"
	+ ]
	+ }
	+}
	diff --git a/test/fixtures/fedidev.fun/tag_hashtag_missing_type.json b/test/fixtures/fedidev.fun/tag_hashtag_missing_type.json
	new file mode 100644
	index 000000000..74f9d91b8
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/tag_hashtag_missing_type.json
	@@ -0,0 +1,30 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/tag-hashtag-missing-type",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:41:00Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-tag-hashtag-missing-type",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:41:00Z",
	+ "content": "hashtag without type",
	+ "tag": [
	+ {
	+ "name": "#Test"
	+ }
	+ ]
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/tag_mention_missing_type.json b/test/fixtures/fedidev.fun/tag_mention_missing_type.json
	new file mode 100644
	index 000000000..d290be6c2
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/tag_mention_missing_type.json
	@@ -0,0 +1,31 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/tag-mention-missing-type",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:41:01Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-tag-mention-missing-type",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:41:01Z",
	+ "content": "mention without type",
	+ "tag": [
	+ {
	+ "name": "@bob",
	+ "href": "https://remote.example/users/bob"
	+ }
	+ ]
	+ }
	+}
	+
	diff --git a/test/fixtures/fedidev.fun/url_list.json b/test/fixtures/fedidev.fun/url_list.json
	new file mode 100644
	index 000000000..b4cfd4cd6
	--- /dev/null
	+++ b/test/fixtures/fedidev.fun/url_list.json
	@@ -0,0 +1,27 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams"
	+ ],
	+ "type": "Create",
	+ "id": "https://fedidev.fun/activity/url-list",
	+ "actor": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:39:06Z",
	+ "object": {
	+ "type": "Note",
	+ "id": "https://fedidev.fun/objects/note-url-list",
	+ "attributedTo": "https://fedidev.fun/users/alice",
	+ "to": [
	+ "https://www.w3.org/ns/activitystreams#Public"
	+ ],
	+ "cc": [],
	+ "published": "2025-11-21T14:39:06Z",
	+ "content": "text",
	+ "url": [
	+ "https://fedidev.fun/objects/123"
	+ ]
	+ }
	+}
	diff --git a/test/pleroma/object/containment_test.exs b/test/pleroma/object/containment_test.exs
	index cf906ef47..5560dfce5 100644
	--- a/test/pleroma/object/containment_test.exs
	+++ b/test/pleroma/object/containment_test.exs
	@@ -1,125 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.ContainmentTest do
	use Pleroma.DataCase

	alias Pleroma.Object.Containment
	alias Pleroma.User

	import Pleroma.Factory
	import ExUnit.CaptureLog

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "general origin containment" do
	test "works for completely actorless posts" do
	assert :error ==
	Containment.contain_origin("https://glaceon.social/users/monorail", %{
	"deleted" => "2019-10-30T05:48:50.249606Z",
	"formerType" => "Note",
	"id" => "https://glaceon.social/users/monorail/statuses/103049757364029187",
	"type" => "Tombstone"
	})
	end

	+ test "rejects an empty actor list without crashing" do
	+ assert :error ==
	+ Containment.contain_origin("https://example.com/objects/1", %{"actor" => []})
	+ end
	+
	test "contain_origin_from_id() catches obvious spoofing attempts" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:error =
	Containment.contain_origin_from_id(
	"http://example.org/~alyssa/activities/1234.json",
	data
	)
	end

	test "contain_origin_from_id() allows alternate IDs within the same origin domain" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Containment.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234",
	data
	)
	end

	test "contain_origin_from_id() allows matching IDs" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Containment.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234.json",
	data
	)
	end

	test "users cannot be collided through fake direction spoofing attempts" do
	_user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	assert capture_log(fn ->
	{:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	end) =~
	"[error] Could not decode user at fetch https://n1u.moe/users/rye"
	end

	test "contain_origin_from_id() gracefully handles cases where no ID is present" do
	data = %{
	"type" => "Create",
	"object" => %{
	"id" => "http://example.net/~alyssa/activities/1234",
	"attributedTo" => "http://example.org/~alyssa"
	},
	"actor" => "http://example.com/~bob"
	}

	:error =
	Containment.contain_origin_from_id("http://example.net/~alyssa/activities/1234", data)
	end
	end

	describe "containment of children" do
	test "contain_child() catches spoofing attempts" do
	data = %{
	"id" => "http://example.com/whatever",
	"type" => "Create",
	"object" => %{
	"id" => "http://example.net/~alyssa/activities/1234",
	"attributedTo" => "http://example.org/~alyssa"
	},
	"actor" => "http://example.com/~bob"
	}

	:error = Containment.contain_child(data)
	end

	test "contain_child() allows correct origins" do
	data = %{
	"id" => "http://example.org/~alyssa/activities/5678",
	"type" => "Create",
	"object" => %{
	"id" => "http://example.org/~alyssa/activities/1234",
	"attributedTo" => "http://example.org/~alyssa"
	},
	"actor" => "http://example.org/~alyssa"
	}

	:ok = Containment.contain_child(data)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	index 68e39b3a0..0de9618d4 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,2963 +1,3107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Workers.ReceiverWorker
	alias Pleroma.Workers.SignatureRetryWorker

	import Pleroma.Factory

	require Pleroma.Constants

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :federating], true)

	defp assign_valid_signature_for_actor(conn, %User{ap_id: actor_id}) do
	assign_valid_signature_for_actor(conn, actor_id)
	end

	defp assign_valid_signature_for_actor(conn, actor) do
	actor_id = Utils.get_ap_id(actor)

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("signature", "keyId=\"#{actor_id}#main-key\"")
	end

	defp expect_signature_retry_from(%User{} = signer) do
	signer_json = UserView.render("user.json", %{user: signer}) \|> Map.delete("featured")

	Tesla.Mock.mock(fn
	%{url: url} when url == signer.ap_id ->
	%Tesla.Env{
	status: 200,
	body: Jason.encode!(signer_json),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	Mox.expect(Pleroma.StubbedHTTPSignaturesMock, :validate_conn, fn _conn -> true end)
	end

	describe "/relay" do
	setup do: clear_config([:instance, :allow_relay])

	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	clear_config([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end
	end

	describe "/internal/fetch" do
	test "it returns the internal fetch user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(200)

	assert res["id"] =~ "/fetch"
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(404)
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user with accept application/json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/activity+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/ld+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns 404 for remote users", %{
	conn: conn
	} do
	user = insert(:user, local: false, nickname: "remoteuser@example.com")

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}.json")

	assert json_response(conn, 404)
	end

	test "it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end
	end

	describe "mastodon compatibility routes" do
	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "it returns a json representation of the activity with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	{:ok, activity, _} =
	%{
	"id" => object.data["id"] <> "/activity",
	"type" => "Create",
	"object" => object.data["id"],
	"actor" => object.data["actor"],
	"to" => object.data["to"]
	}
	\|> ActivityPub.persist(local: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999/activity")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end
	end

	describe "/objects/:uuid" do
	test "it doesn't return a local-only object", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns local-only objects when authenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(response, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "does not return local-only objects for remote users", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user, local: false)

	{:ok, post} =
	CommonAPI.post(user, %{status: "test @#{reader.nickname}", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	json_response(response, 404)
	end

	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/activity+json",
	%{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/ld+json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "does not cache authenticated response", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user)

	{:ok, post} =
	CommonAPI.post(user, %{status: "test @#{reader.nickname}", visibility: "local"})

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	json_response(response, 200)

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(404)
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns visible non-public messages when authenticated", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()
	user = User.get_by_ap_id(note.data["actor"])
	marisa = insert(:user)

	assert conn
	\|> assign(:user, marisa)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(404)

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(200)

	assert response == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after object deletion", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Object.delete(note)

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/objects/:uuid/replies" do
	test "it renders the top-level collection", %{
	conn: conn
	} do
	user = insert(:user)
	note = insert(:note_activity)
	note = Pleroma.Activity.get_by_id_with_object(note.id)
	uuid = String.split(note.object.data["id"], "/") \|> List.last()

	{:ok, _} =
	CommonAPI.post(user, %{status: "reply1", in_reply_to_status_id: note.id})

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}/replies")

	assert match?(
	%{
	"id" => _,
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"first" => %{
	"id" => _,
	"type" => "OrderedCollectionPage",
	"orderedItems" => [_]
	}
	},
	json_response(conn, 200)
	)
	end

	test "first page id includes `?page=true`", %{conn: conn} do
	user = insert(:user)
	note = insert(:note_activity)
	note = Pleroma.Activity.get_by_id_with_object(note.id)
	uuid = String.split(note.object.data["id"], "/") \|> List.last()

	{:ok, _} =
	CommonAPI.post(user, %{status: "reply1", in_reply_to_status_id: note.id})

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}/replies")

	%{"id" => collection_id, "first" => %{"id" => page_id, "partOf" => part_of}} =
	json_response(conn, 200)

	assert part_of == collection_id
	assert String.contains?(page_id, "page=true")
	end

	test "unknown query params do not crash the endpoint", %{conn: conn} do
	user = insert(:user)
	note = insert(:note_activity)
	note = Pleroma.Activity.get_by_id_with_object(note.id)
	uuid = String.split(note.object.data["id"], "/") \|> List.last()

	{:ok, _} =
	CommonAPI.post(user, %{status: "reply1", in_reply_to_status_id: note.id})

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}/replies?unknown_param=1")

	assert %{"type" => "OrderedCollection"} = json_response(conn, 200)
	end

	test "it renders a collection page", %{
	conn: conn
	} do
	user = insert(:user)
	note = insert(:note_activity)
	note = Pleroma.Activity.get_by_id_with_object(note.id)
	uuid = String.split(note.object.data["id"], "/") \|> List.last()

	{:ok, r1} =
	CommonAPI.post(user, %{status: "reply1", in_reply_to_status_id: note.id})

	{:ok, r2} =
	CommonAPI.post(user, %{status: "reply2", in_reply_to_status_id: note.id})

	{:ok, _} =
	CommonAPI.post(user, %{status: "reply3", in_reply_to_status_id: note.id})

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}/replies?page=true&min_id=#{r1.object.id}&limit=1")

	expected_uris = [r2.object.data["id"]]

	assert match?(
	%{
	"id" => _,
	"type" => "OrderedCollectionPage",
	"prev" => _,
	"next" => _,
	"orderedItems" => ^expected_uris
	},
	json_response(conn, 200)
	)
	end
	end

	describe "/activities/:uuid" do
	test "it does not include a top-level replies collection on activities", %{conn: conn} do
	clear_config([:activitypub, :note_replies_output_limit], 1)

	activity = insert(:note_activity)
	activity = Activity.get_by_id_with_object(activity.id)

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	res = json_response(conn, 200)

	refute Map.has_key?(res, "replies")
	assert get_in(res, ["object", "replies", "id"]) == activity.object.data["id"] <> "/replies"
	end

	test "it doesn't return a local-only activity", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns local-only activities when authenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(response, 200) == ObjectView.render("object.json", %{object: post})
	end

	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns visible non-public messages when authenticated", %{conn: conn} do
	note = insert(:direct_note_activity)
	uuid = String.split(note.data["id"], "/") \|> List.last()
	user = User.get_by_ap_id(note.data["actor"])
	marisa = insert(:user)

	assert conn
	\|> assign(:user, marisa)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")
	\|> json_response(404)

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")
	\|> json_response(200)

	assert response == ObjectView.render("object.json", %{object: note})
	end

	test "it caches a response", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after activity deletion", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe"})

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Activity.delete_all_by_object_ap_id(activity.object.data["id"])

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	+ test "rejects duplicate Signature headers before processing signed inbox requests", %{
	+ conn: conn
	+ } do
	+ data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()
	+
	+ conn =
	+ conn
	+ \|> assign_valid_signature_for_actor(data["actor"])
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> Map.update!(:req_headers, &[{"signature", "sig1=:fake-signature:"} \| &1])
	+ \|> post("/inbox", data)
	+
	+ assert "error, unsupported HTTP Message Signature" == json_response(conn, 401)
	+ assert [] == all_enqueued(worker: ReceiverWorker)
	+ end
	+
	test "it inserts an incoming activity into the database" <>
	"even if we can't fetch the user but have it in our db",
	%{conn: conn} do
	user =
	insert(:user,
	ap_id: "https://mastodon.example.org/users/raymoo",
	local: false,
	last_refreshed_at: nil
	)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> put_in(["object", "attributedTo"], user.ap_id)

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	+ test "rejects unsupported HTTP Message Signatures so clients can fall back", %{conn: conn} do
	+ data = %{
	+ "type" => "Create",
	+ "actor" => "https://activitypubbot.example/user/ok",
	+ "id" => "https://activitypubbot.example/activities/rfc9421-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://activitypubbot.example/objects/rfc9421-note",
	+ "actor" => "https://activitypubbot.example/user/ok",
	+ "attributedTo" => "https://activitypubbot.example/user/ok",
	+ "content" => "hello from activitypub-bot",
	+ "published" => "2026-05-29T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ Mox.expect(Pleroma.StubbedHTTPSignaturesMock, :validate_conn, fn _conn -> false end)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("date", "Fri, 29 May 2026 13:33:31 GMT")
	+ \|> put_req_header("content-digest", "sha-256=:fake-digest:")
	+ \|> put_req_header(
	+ "signature-input",
	+ "sig1=(\"@method\" \"@target-uri\" \"date\" \"content-type\" \"content-digest\");keyid=\"https://activitypubbot.example/user/ok/publickey\";alg=\"rsa-v1_5-sha256\";created=1780061611"
	+ )
	+ \|> put_req_header("signature", "sig1=:fake-signature:")
	+ \|> post("/inbox", data)
	+
	+ assert "error, unsupported HTTP Message Signature" == json_response(conn, 401)
	+ assert [] == all_enqueued(worker: SignatureRetryWorker)
	+ end
	+
	+ test "rejects duplicate Signature headers so clients can fall back", %{conn: conn} do
	+ data = %{
	+ "type" => "Create",
	+ "actor" => "https://activitypubbot.example/user/ok",
	+ "id" => "https://activitypubbot.example/activities/duplicate-signature-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://activitypubbot.example/objects/duplicate-signature-note",
	+ "actor" => "https://activitypubbot.example/user/ok",
	+ "attributedTo" => "https://activitypubbot.example/user/ok",
	+ "content" => "hello from activitypub-bot",
	+ "published" => "2026-05-29T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ legacy_signature =
	+ "keyId=\"https://activitypubbot.example/user/ok#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	+
	+ Mox.expect(Pleroma.StubbedHTTPSignaturesMock, :validate_conn, fn _conn -> false end)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("date", "Fri, 29 May 2026 13:33:31 GMT")
	+ \|> put_req_header("digest", "SHA-256=fake-digest")
	+ \|> put_req_header("signature", "sig1=:fake-signature:")
	+ \|> Map.update!(:req_headers, &[{"signature", legacy_signature} \| &1])
	+ \|> post("/inbox", data)
	+
	+ assert "error, unsupported HTTP Message Signature" == json_response(conn, 401)
	+ assert [] == all_enqueued(worker: SignatureRetryWorker)
	+ end
	+
	+ test "keeps failed-signature retry for legacy signatures with Signature-Input", %{conn: conn} do
	+ data = %{
	+ "type" => "Create",
	+ "actor" => "https://activitypubbot.example/user/ok",
	+ "id" => "https://activitypubbot.example/activities/legacy-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://activitypubbot.example/objects/legacy-note",
	+ "actor" => "https://activitypubbot.example/user/ok",
	+ "attributedTo" => "https://activitypubbot.example/user/ok",
	+ "content" => "hello from activitypub-bot",
	+ "published" => "2026-05-29T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ Mox.expect(Pleroma.StubbedHTTPSignaturesMock, :validate_conn, fn _conn -> false end)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("date", "Fri, 29 May 2026 13:33:31 GMT")
	+ \|> put_req_header("digest", "SHA-256=fake-digest")
	+ \|> put_req_header(
	+ "signature-input",
	+ "sig1=(\"@method\" \"@target-uri\" \"date\" \"content-type\" \"digest\");keyid=\"https://activitypubbot.example/user/ok/publickey\";alg=\"rsa-v1_5-sha256\";created=1780061611"
	+ )
	+ \|> put_req_header(
	+ "signature",
	+ "keyId=\"https://activitypubbot.example/user/ok#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	+ )
	+ \|> post("/inbox", data)
	+
	+ assert "ok" == json_response(conn, 200)
	+ assert [_] = all_enqueued(worker: SignatureRetryWorker)
	+ end
	+
	test "does not create a forged post after failed signature retry", %{conn: conn} do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	object_id = "https://two.com/objects/inbox-forged-note"

	data = %{
	"type" => "Create",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/inbox-forged-create",
	"context" => "https://two.com/contexts/inbox-forged-create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => object_id,
	"actor" => bob.ap_id,
	"attributedTo" => bob.ap_id,
	"context" => "https://two.com/contexts/inbox-forged-create",
	"content" => "forged post",
	"published" => "2024-07-25T13:33:31Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => []
	}
	}

	expect_signature_retry_from(alice)

	conn =
	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header("content-type", "application/activity+json")
	\|> put_req_header("signature", "keyId=\"https://one.com/users/alice#main-key\"")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	assert [{:cancel, :actor_signature_mismatch}] =
	ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))

	refute Activity.get_by_ap_id(data["id"])
	refute Object.get_by_ap_id(object_id)
	end

	test "does not create a forged like after failed signature retry", %{conn: conn} do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	note = insert(:note)

	data = %{
	"type" => "Like",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/inbox-forged-like",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => note.data["id"]
	}

	expect_signature_retry_from(alice)

	conn =
	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header("content-type", "application/activity+json")
	\|> put_req_header("signature", "keyId=\"https://one.com/users/alice#main-key\"")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	assert [{:cancel, :actor_signature_mismatch}] =
	ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))

	refute Activity.get_by_ap_id(data["id"])
	end

	test "does not delete an object after failed signature retry", %{conn: conn} do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	note = insert(:note)
	object_id = note.data["id"]

	data = %{
	"type" => "Delete",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/inbox-forged-delete",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => object_id
	}

	expect_signature_retry_from(alice)

	conn =
	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header("content-type", "application/activity+json")
	\|> put_req_header("signature", "keyId=\"https://one.com/users/alice#main-key\"")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	assert [{:cancel, :actor_signature_mismatch}] =
	ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))

	refute Activity.get_by_ap_id(data["id"])
	assert %Object{data: %{"type" => "Note"}} = Object.get_by_ap_id(object_id)
	end

	test "does not create a forged post signed by a different actor", %{conn: conn} do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	object_id = "https://two.com/objects/inbox-signed-forged-note"

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/inbox-signed-forged-create",
	"context" => "https://two.com/contexts/inbox-signed-forged-create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => object_id,
	"actor" => bob.ap_id,
	"attributedTo" => bob.ap_id,
	"context" => "https://two.com/contexts/inbox-signed-forged-create",
	"content" => "forged post",
	"published" => "2024-07-25T13:33:31Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => []
	}
	}

	expect_signature_retry_from(alice)

	conn =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> put_req_header("date", "Thu, 25 Jul 2024 13:33:31 GMT")
	\|> put_req_header("digest", "SHA-256=fake-digest")
	\|> put_req_header(
	"signature",
	"keyId=\"#{alice.ap_id}#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	)
	\|> post("/inbox", data)

	assert conn.assigns.valid_signature == false
	assert "ok" == json_response(conn, 200)

	assert [{:cancel, :actor_signature_mismatch}] =
	ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))

	refute Activity.get_by_ap_id(data["id"])
	refute Object.get_by_ap_id(object_id)
	end

	test "does not create a forged like signed by a different actor", %{conn: conn} do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	note = insert(:note)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Like",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/inbox-signed-forged-like",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => note.data["id"]
	}

	expect_signature_retry_from(alice)

	conn =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> put_req_header("date", "Thu, 25 Jul 2024 13:33:31 GMT")
	\|> put_req_header("digest", "SHA-256=fake-digest")
	\|> put_req_header(
	"signature",
	"keyId=\"#{alice.ap_id}#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	)
	\|> post("/inbox", data)

	assert conn.assigns.valid_signature == false
	assert "ok" == json_response(conn, 200)

	assert [{:cancel, :actor_signature_mismatch}] =
	ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))

	refute Activity.get_by_ap_id(data["id"])
	end

	test "does not process post with Host header not for us", %{conn: conn} do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	object_id = "https://one.com/objects/inbox-forged-note"

	data = %{
	"type" => "Create",
	"actor" => alice.ap_id,
	"id" => "https://one.com/activities/inbox-forged-create",
	"context" => "https://one.com/contexts/inbox-forged-create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => object_id,
	"actor" => alice.ap_id,
	"attributedTo" => alice.ap_id,
	"context" => "https://one.com/contexts/inbox-forged-create",
	"content" => "forged post",
	"published" => "2024-07-25T13:33:31Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => []
	}
	}

	# Plug will complain when replacing raw host header with put_req_header.
	# The Plug way is updating conn.host, but that isn't the raw header
	# and that isn't used in the EnsureHostMatchesPlug, because it doesn't include the port.
	conn =
	conn
	\|> assign_valid_signature_for_actor(alice)
	\|> delete_req_header("host")
	\|> put_req_header("content-type", "application/activity+json")

	conn = %{conn \| req_headers: conn.req_headers ++ [{"host", "invalid.example.com"}]}
	conn = post(conn, "/inbox", data)

	assert "Host header does not match this instance" == conn.resp_body
	assert 400 == conn.status
	assert true == conn.halted

	refute Activity.get_by_ap_id(data["id"])
	refute Object.get_by_ap_id(object_id)
	end

	test "accept follow activity", %{conn: conn} do
	clear_config([:instance, :federating], true)
	relay = Relay.get_actor()

	assert {:ok, %Activity{} = activity} = Relay.follow("https://relay.mastodon.host/actor")

	followed_relay = Pleroma.User.get_by_ap_id("https://relay.mastodon.host/actor")
	relay = refresh_record(relay)

	accept =
	File.read!("test/fixtures/relay/accept-follow.json")
	\|> String.replace("{{ap_id}}", relay.ap_id)
	\|> String.replace("{{activity_id}}", activity.data["id"])

	assert "ok" ==
	conn
	\|> assign_valid_signature_for_actor(followed_relay)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", accept)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.FollowingRelationship.following?(
	relay,
	followed_relay
	)

	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])
	assert_receive {:mix_shell, :info, ["https://relay.mastodon.host/actor"]}
	end

	test "without valid signature, " <>
	"it accepts Create activities and requires enabled federation",
	%{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()
	non_create_data = File.read!("test/fixtures/mastodon-announce.json") \|> Jason.decode!()

	conn = put_req_header(conn, "content-type", "application/activity+json")

	clear_config([:instance, :federating], false)

	conn
	\|> post("/inbox", data)
	\|> json_response(403)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(403)

	clear_config([:instance, :federating], true)

	ret_conn = post(conn, "/inbox", data)
	assert "ok" == json_response(ret_conn, 200)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(400)
	end

	# When activity is delivered to the inbox and we cannot immediately verify signature
	# we capture all the params and process it later in the Oban job.
	# Once we begin processing it through Oban we risk fetching the actor to validate the
	# activity which just leads to inserting a new user to process a Delete not relevant to us.
	test "Activities of certain types from an unknown actor are discarded", %{conn: conn} do
	example_bad_types =
	Pleroma.Constants.activity_types() --
	Pleroma.Constants.allowed_activity_types_from_strangers()

	Enum.each(example_bad_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	"actor" => "https://unknown.mastodon.instance/users/somebody"
	}
	\|> Jason.encode!()

	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", params)
	\|> json_response(400)

	assert all_enqueued() == []
	end)
	end

	test "Unknown activity types are discarded", %{conn: conn} do
	unknown_types = ["Poke", "Read", "Dazzle"]

	actor =
	insert(:user, local: false, ap_id: "https://unknown.mastodon.instance/users/somebody")

	Enum.each(unknown_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	"actor" => actor.ap_id
	}
	\|> Jason.encode!()

	conn
	\|> assign_valid_signature_for_actor(actor)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", params)
	\|> json_response(400)

	assert all_enqueued() == []
	end)
	end

	test "accepts Add/Remove activities", %{conn: conn} do
	object_id = "c61d6733-e256-4fe1-ab13-1e369789423f"

	status =
	File.read!("test/fixtures/statuses/note.json")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	user =
	File.read!("test/fixtures/users_mock/user.json")
	\|> String.replace("{{nickname}}", "lain")

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: status,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423f",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()]
	}

	assert "ok" ==
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	user = User.get_cached_by_ap_id(data["actor"])
	assert user.pinned_objects[data["object"]]

	data = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423d",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()]
	}

	assert "ok" ==
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	user = refresh_record(user)
	refute user.pinned_objects[data["object"]]
	end

	test "mastodon pin/unpin", %{conn: conn} do
	status_id = "105786274556060421"

	status =
	File.read!("test/fixtures/statuses/masto-note.json")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{status_id}}", status_id)

	status_url = "https://example.com/users/lain/statuses/#{status_id}"

	user =
	File.read!("test/fixtures/users_mock/user.json")
	\|> String.replace("{{nickname}}", "lain")

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^status_url
	} ->
	%Tesla.Env{
	status: 200,
	body: status,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => actor,
	"object" => status_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add"
	}

	assert "ok" ==
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_object_ap_id_with_object(data["object"])
	user = User.get_cached_by_ap_id(data["actor"])
	assert user.pinned_objects[data["object"]]

	data = %{
	"actor" => actor,
	"object" => status_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove"
	}

	assert "ok" ==
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_object_ap_id_with_object(data["object"])
	user = refresh_record(user)
	refute user.pinned_objects[data["object"]]
	end
	end

	describe "/users/:nickname/inbox" do
	setup do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	[data: data]
	end

	test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	+ test "rejects duplicate Signature headers", %{conn: conn, data: data} do
	+ user = insert(:user)
	+
	+ conn =
	+ conn
	+ \|> assign_valid_signature_for_actor(data["actor"])
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> Map.update!(:req_headers, &[{"signature", "sig1=:fake-signature:"} \| &1])
	+ \|> post("/users/#{user.nickname}/inbox", data)
	+
	+ assert "error, unsupported HTTP Message Signature" == json_response(conn, 401)
	+ assert [] == all_enqueued(worker: ReceiverWorker)
	+ end
	+
	test "it accepts messages with to as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", user.ap_id)
	\|> Map.put("cc", [])
	\|> Kernel.put_in(["object", "to"], user.ap_id)
	\|> Kernel.put_in(["object", "cc"], [])

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with cc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", [])
	\|> Map.put("cc", user.ap_id)
	\|> Kernel.put_in(["object", "to"], [])
	\|> Kernel.put_in(["object", "cc"], user.ap_id)

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert user.ap_id in activity.recipients
	end

	test "it accepts messages with bcc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", [])
	\|> Map.put("cc", [])
	\|> Map.put("bcc", user.ap_id)
	\|> Kernel.put_in(["object", "to"], [])
	\|> Kernel.put_in(["object", "cc"], [])
	\|> Kernel.put_in(["object", "bcc"], user.ap_id)

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts announces with to as string instead of array", %{conn: conn} do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "hey"})
	announcer = insert(:user, local: false)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => announcer.ap_id,
	"id" => "#{announcer.ap_id}/statuses/19512778738411822/activity",
	"object" => post.data["object"],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => [user.ap_id],
	"type" => "Announce"
	}

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.recipients
	end

	test "it accepts messages from actors that are followed by the user", %{
	conn: conn,
	data: data
	} do
	recipient = insert(:user)
	actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})

	{:ok, recipient, actor} = User.follow(recipient, actor)

	object =
	data["object"]
	\|> Map.put("attributedTo", actor.ap_id)

	data =
	data
	\|> Map.put("actor", actor.ap_id)
	\|> Map.put("object", object)

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it removes all follower collections but actor's", %{conn: conn} do
	[actor, recipient] = insert_pair(:user)

	to = [
	recipient.ap_id,
	recipient.follower_address,
	"https://www.w3.org/ns/activitystreams#Public"
	]

	cc = [recipient.follower_address, actor.follower_address]

	data = %{
	"@context" => ["https://www.w3.org/ns/activitystreams"],
	"type" => "Create",
	"id" => Utils.generate_activity_id(),
	"to" => to,
	"cc" => cc,
	"actor" => actor.ap_id,
	"object" => %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => "It's a note",
	"attributedTo" => actor.ap_id,
	"id" => Utils.generate_object_id()
	}
	}

	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert activity = Activity.get_by_ap_id(data["id"])

	assert activity.id
	assert actor.follower_address in activity.recipients
	assert actor.follower_address in activity.data["cc"]

	refute recipient.follower_address in activity.recipients
	refute recipient.follower_address in activity.data["cc"]
	refute recipient.follower_address in activity.data["to"]
	end

	test "it requires authentication", %{conn: conn} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "application/activity+json")

	ret_conn = get(conn, "/users/#{user.nickname}/inbox")
	assert json_response(ret_conn, 403)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(ret_conn, 200)
	end

	test "forwarded report", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	reported_user = insert(:user)

	note = insert(:note_activity, user: reported_user)

	data = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://#{remote_domain}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	],
	"actor" => actor.ap_id,
	# CC and TO might either not exist at all, or be empty. We should be able to handle either.
	# "cc" => [],
	"content" => "test",
	"context" => "context",
	"id" => "http://#{remote_domain}/activities/02be56cf-35e3-46b4-b2c6-47ae08dfee9e",
	"nickname" => reported_user.nickname,
	"object" => [
	reported_user.ap_id,
	%{
	"actor" => %{
	"actor_type" => "Person",
	"approval_pending" => false,
	"avatar" => "",
	"confirmation_pending" => false,
	"deactivated" => false,
	"display_name" => "test user",
	"id" => reported_user.id,
	"local" => false,
	"nickname" => reported_user.nickname,
	"registration_reason" => nil,
	"roles" => %{
	"admin" => false,
	"moderator" => false
	},
	"tags" => [],
	"url" => reported_user.ap_id
	},
	"content" => "",
	"id" => note.data["id"],
	"published" => note.data["published"],
	"type" => "Note"
	}
	],
	"published" => note.data["published"],
	"state" => "open",
	"to" => [],
	"type" => "Flag"
	}

	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.Repo.aggregate(Activity, :count, :id) == 2

	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/Reported Account:/i
	)
	end

	test "forwarded report from mastodon", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	remote_actor = "https://#{remote_domain}/actor"
	[reported_user, another] = insert_list(2, :user)

	note = insert(:note_activity, user: reported_user)

	Pleroma.Web.CommonAPI.favorite(note.id, another)

	mock_json_body =
	"test/fixtures/mastodon/application_actor.json"
	\|> File.read!()
	\|> String.replace("{{DOMAIN}}", remote_domain)

	Tesla.Mock.mock(fn %{url: ^remote_actor} ->
	%Tesla.Env{
	status: 200,
	body: mock_json_body,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => remote_actor,
	"content" => "test report",
	"id" => "https://#{remote_domain}/e3b12fd1-948c-446e-b93b-a5e67edbe1d8",
	"object" => [
	reported_user.ap_id,
	note.data["object"]
	],
	"type" => "Flag"
	}

	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	flag_activity = "Flag" \|> Pleroma.Activity.Queries.by_type() \|> Pleroma.Repo.one()
	reported_user_ap_id = reported_user.ap_id

	[^reported_user_ap_id, flag_data] = flag_activity.data["object"]

	Enum.each(~w(actor content id published type), &Map.has_key?(flag_data, &1))
	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/#{note.data["object"]}/i
	)
	end

	test "it accepts an incoming Block", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("type", "Block")
	\|> Map.put("to", [user.ap_id])
	\|> Map.put("cc", [])
	\|> Map.put("object", user.ap_id)

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it returns an error when receiving an activity sent to a deactivated user", %{
	conn: conn,
	data: data
	} do
	user = insert(:user)
	{:ok, _} = User.set_activation(user, false)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "User deactivated" == json_response(conn, 404)
	end

	test "it returns an error when receiving an activity sent from a deactivated user", %{
	conn: conn,
	data: data
	} do
	sender = insert(:user)
	user = insert(:user)
	{:ok, _} = User.set_activation(sender, false)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Map.put("actor", sender.ap_id)
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign_valid_signature_for_actor(data["actor"])
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "Sender deactivated" == json_response(conn, 404)
	end
	end

	describe "GET /users/:nickname/outbox" do
	setup do
	Mox.stub_with(Pleroma.StaticStubbedConfigMock, Pleroma.Config)
	:ok
	end

	test "it paginates correctly", %{conn: conn} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	outbox_endpoint = user.ap_id <> "/outbox"

	_posts =
	for i <- 0..25 do
	{:ok, activity} = CommonAPI.post(user, %{status: "post #{i}"})
	activity
	end

	result =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint <> "?page=true")
	\|> json_response(200)

	result_ids = Enum.map(result["orderedItems"], fn x -> x["id"] end)
	assert length(result["orderedItems"]) == 20
	assert length(result_ids) == 20
	assert result["next"]
	assert String.starts_with?(result["next"], outbox_endpoint)

	result_next =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result["next"])
	\|> json_response(200)

	result_next_ids = Enum.map(result_next["orderedItems"], fn x -> x["id"] end)
	assert length(result_next["orderedItems"]) == 6
	assert length(result_next_ids) == 6
	refute Enum.find(result_next_ids, fn x -> x in result_ids end)
	refute Enum.find(result_ids, fn x -> x in result_next_ids end)
	assert String.starts_with?(result["id"], outbox_endpoint)

	result_next_again =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result_next["id"])
	\|> json_response(200)

	assert result_next == result_next_again
	end

	test "it returns 200 even if there're no activities", %{conn: conn} do
	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	result = json_response(conn, 200)
	assert outbox_endpoint == result["id"]
	end

	test "it returns a local note activity when authenticated as local user", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user)
	{:ok, note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})
	ap_id = note_activity.data["id"]

	resp =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => [%{"id" => ^ap_id}]} = resp
	end

	test "it does not return a local note activity when unauthenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, _note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})

	resp =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => []} = resp
	end

	test "it does not return a local note activity when C2S API is disabled", %{conn: conn} do
	clear_config([:activitypub, :client_api_enabled], false)
	user = insert(:user)
	reader = insert(:user)
	{:ok, _note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})

	resp =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => []} = resp
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ announce_activity.data["object"]
	end

	test "It returns poll Answers when authenticated", %{conn: conn} do
	poller = insert(:user)
	voter = insert(:user)

	{:ok, activity} =
	CommonAPI.post(poller, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	assert question = Object.normalize(activity, fetch: false)

	{:ok, [activity], _object} = CommonAPI.vote(question, voter, [1])

	assert outbox_get =
	conn
	\|> assign(:user, voter)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(voter.ap_id <> "/outbox?page=true")
	\|> json_response(200)

	assert [answer_outbox] = outbox_get["orderedItems"]
	assert answer_outbox["id"] == activity.data["id"]
	end

	test "it works with authorized fetch forced when authenticated" do
	clear_config([:activitypub, :authorized_fetch_mode], true)

	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	assert json_response(conn, 200)
	end

	test "it fails with authorized fetch forced when unauthenticated", %{conn: conn} do
	clear_config([:activitypub, :authorized_fetch_mode], true)

	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	assert response(conn, 401)
	end
	end

	describe "POST /users/:nickname/outbox (C2S)" do
	setup do: clear_config([:instance, :limit])

	setup do
	[
	activity: %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	}
	]
	end

	test "it rejects posts from other users / unauthenticated users", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	other_user = insert(:user)
	conn = put_req_header(conn, "content-type", "application/activity+json")

	conn
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)

	conn
	\|> assign(:user, other_user)
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)
	end

	test "it inserts an incoming create activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])
	assert result["object"]
	assert %Object{data: object} = Object.normalize(result["object"], fetch: false)
	assert object["content"] == activity["object"]["content"]
	end

	test "it inserts an incoming reply create activity into the database", %{conn: conn} do
	user = insert(:user)
	replying_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "cofe"})

	data = %{
	type: "Create",
	object: %{
	to: [Pleroma.Constants.as_public(), user.ap_id],
	cc: [replying_user.follower_address],
	inReplyTo: activity.object.data["id"],
	content: "green tea",
	type: "Note"
	}
	}

	result =
	conn
	\|> assign(:user, replying_user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{replying_user.nickname}/outbox", data)
	\|> json_response(201)

	updated_object = Object.normalize(activity.object.data["id"], fetch: false)

	assert Activity.get_by_ap_id(result["id"])
	assert result["object"]
	assert %Object{data: object} = Object.normalize(result["object"], fetch: false)
	assert object["content"] == data.object.content
	assert Pleroma.Web.ActivityPub.Visibility.public?(object)
	assert object["inReplyTo"] == activity.object.data["id"]
	assert updated_object.data["repliesCount"] == 1
	end

	test "it rejects anything beyond 'Note' creations", %{conn: conn, activity: activity} do
	user = insert(:user)

	activity =
	activity
	\|> put_in(["object", "type"], "Benis")

	_result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)
	end

	test "it inserts an incoming sensitive activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	object = Map.put(activity["object"], "sensitive", true)
	activity = Map.put(activity, "object", object)

	response =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(response["id"])
	assert response["object"]
	assert %Object{data: response_object} = Object.normalize(response["object"], fetch: false)
	assert response_object["sensitive"] == true
	assert response_object["content"] == activity["object"]["content"]

	representation =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(response["id"])
	\|> json_response(200)

	assert representation["object"]["sensitive"] == true
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn, activity: activity} do
	user = insert(:user)
	activity = Map.put(activity, "type", "BadType")

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	"type" => "Delete",
	"object" => %{
	"id" => note_object.data["id"]
	}
	}

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it rejects update activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data = %{
	type: "Update",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	assert note_object == Object.normalize(note_activity, fetch: false)
	end

	test "it rejects Add to other user's collection", %{conn: conn} do
	user = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Post"})
	object = Object.normalize(activity, fetch: false)
	object_id = object.data["id"]

	data = %{
	type: "Add",
	target:
	"#{Pleroma.Web.Endpoint.url()}/users/#{target_user.nickname}/collections/featured",
	object: object_id
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it rejects Remove to other user's collection", %{conn: conn} do
	user = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Post"})
	object = Object.normalize(activity, fetch: false)
	object_id = object.data["id"]

	data = %{
	type: "Remove",
	target:
	"#{Pleroma.Web.Endpoint.url()}/users/#{target_user.nickname}/collections/featured",
	object: object_id
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it rejects updating Actor's profile", %{conn: conn} do
	user = insert(:user, local: true)

	user_object = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
	user_object_new = Map.put(user_object, "name", "lain")

	data = %{
	type: "Update",
	object: user_object_new
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/users/#{user.nickname}/outbox", data)

	updated_user_object = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	assert updated_user_object == user_object
	assert json_response(conn, 400)
	end

	# Actor publicKey tests are redundant with above test,
	# left here for the case that Updating Actors is ever supported
	test "it rejects updating Actor's publicKey", %{conn: conn} do
	user = insert(:user, local: true)

	{:ok, pem} = Pleroma.Keys.generate_rsa_pem()
	{:ok, _, public_key} = Pleroma.Keys.keys_from_pem(pem)
	# Taken from UserView
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])

	user_object = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
	user_object_public_key = Map.fetch!(user_object, "publicKey")
	user_object_public_key = Map.put(user_object_public_key, "publicKeyPem", public_key)
	user_object_new = Map.put(user_object, "publicKey", user_object_public_key)

	refute user_object == user_object_new

	data = %{
	type: "Update",
	object: user_object_new
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/users/#{user.nickname}/outbox", data)

	new_user_object = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	assert user_object == new_user_object
	assert json_response(conn, 400)
	end

	test "it rejects updating Actor's publicKey of another user", %{conn: conn} do
	user = insert(:user)
	target_user = insert(:user, local: true)

	{:ok, pem} = Pleroma.Keys.generate_rsa_pem()
	{:ok, _, public_key} = Pleroma.Keys.keys_from_pem(pem)
	# Taken from UserView
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])

	target_user_object =
	Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: target_user})

	target_user_object_public_key = Map.fetch!(target_user_object, "publicKey")

	target_user_object_public_key =
	Map.put(target_user_object_public_key, "publicKeyPem", public_key)

	target_user_object_new =
	Map.put(target_user_object, "publicKey", target_user_object_public_key)

	refute target_user_object == target_user_object_new

	data = %{
	type: "Update",
	object: target_user_object_new
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/users/#{target_user.nickname}/outbox", data)

	new_target_user_object =
	Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: target_user})

	assert target_user_object == new_target_user_object
	assert json_response(conn, 403)
	end

	test "it rejects creating Actors of type Application", %{conn: conn} do
	user = insert(:user, local: true)

	data = %{
	type: "Create",
	object: %{
	type: "Application"
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it rejects creating Actors of type Person", %{conn: conn} do
	user = insert(:user, local: true)

	data = %{
	type: "Create",
	object: %{
	type: "Person"
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it rejects creating Actors of type Service", %{conn: conn} do
	user = insert(:user, local: true)

	data = %{
	type: "Create",
	object: %{
	type: "Service"
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it rejects like activity to object invisible to actor", %{conn: conn} do
	user = insert(:user)
	stranger = insert(:user, local: true)
	{:ok, post} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, stranger)

	post_object = Object.normalize(post, fetch: false)

	data = %{
	type: "Like",
	object: %{
	id: post_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, stranger)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{stranger.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it rejects announce activity to object invisible to actor", %{conn: conn} do
	user = insert(:user)
	stranger = insert(:user, local: true)
	{:ok, post} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, stranger)

	post_object = Object.normalize(post, fetch: false)

	data = %{
	type: "Announce",
	object: %{
	id: post_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, stranger)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{stranger.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it rejects emojireact activity to object invisible to actor", %{conn: conn} do
	user = insert(:user)
	stranger = insert(:user, local: true)
	{:ok, post} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, stranger)

	post_object = Object.normalize(post, fetch: false)

	data = %{
	type: "EmojiReact",
	object: %{
	id: post_object.data["id"]
	},
	content: "😀"
	}

	conn =
	conn
	\|> assign(:user, stranger)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{stranger.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end

	test "it doesn't spreads faulty attributedTo or actor fields", %{
	conn: conn,
	activity: activity
	} do
	reimu = insert(:user, nickname: "reimu")
	cirno = insert(:user, nickname: "cirno")

	assert reimu.ap_id
	assert cirno.ap_id

	activity =
	activity
	\|> put_in(["object", "actor"], reimu.ap_id)
	\|> put_in(["object", "attributedTo"], reimu.ap_id)
	\|> put_in(["actor"], reimu.ap_id)
	\|> put_in(["attributedTo"], reimu.ap_id)

	_reimu_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reimu.nickname}/outbox", activity)
	\|> json_response(403)

	cirno_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{cirno.nickname}/outbox", activity)
	\|> json_response(201)

	assert cirno_outbox["attributedTo"] == nil
	assert cirno_outbox["actor"] == cirno.ap_id

	assert cirno_object = Object.normalize(cirno_outbox["object"], fetch: false)
	assert cirno_object.data["actor"] == cirno.ap_id
	assert cirno_object.data["attributedTo"] == cirno.ap_id
	end

	test "Character limitation", %{conn: conn, activity: activity} do
	clear_config([:instance, :limit], 5)
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)

	assert result == "Character limit (5 characters) exceeded, contains 11 characters"
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/followers")
	\|> json_response(404)
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/following")
	\|> json_response(404)
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user_two)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_followers: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{other_user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_followers: true)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additional ActivityPub C2S endpoints" do
	test "GET /api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

	assert UserView.render("user.json", %{user: user}) == json_response(conn, 200)

	conn
	\|> get("/api/ap/whoami")
	\|> json_response(403)
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	# majic's libmagic port is unavailable on local Darwin runs; Linux CI still runs this test.
	@tag :skip_darwin
	test "POST /api/ap/upload_media", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	object =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(:created)

	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	assert [%{"href" => object_href, "mediaType" => object_mediatype}] = object["url"]
	assert is_binary(object_href)
	assert object_mediatype == "image/jpeg"
	assert String.ends_with?(object_href, ".jpg")

	activity_request = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test, attachment",
	"attachment" => [object],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	}

	activity_response =
	conn
	\|> assign(:user, user)
	\|> post("/users/#{user.nickname}/outbox", activity_request)
	\|> json_response(:created)

	assert activity_response["id"]
	assert activity_response["object"]
	assert activity_response["actor"] == user.ap_id

	assert %Object{data: %{"attachment" => [attachment]}} =
	Object.normalize(activity_response["object"], fetch: false)

	assert attachment["type"] == "Document"
	assert attachment["name"] == desc

	assert [
	%{
	"href" => ^object_href,
	"type" => "Link",
	"mediaType" => ^object_mediatype
	}
	] = attachment["url"]

	# Fails if unauthenticated
	conn
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(403)
	end

	test "they don't work when C2S API is disabled", %{conn: conn} do
	clear_config([:activitypub, :client_api_enabled], false)

	user = insert(:user)

	assert conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")
	\|> response(403)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	assert conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> response(403)
	end
	end

	test "pinned collection", %{conn: conn} do
	clear_config([:instance, :max_pinned_statuses], 2)
	user = insert(:user)
	objects = insert_list(2, :note, user: user)

	Enum.reduce(objects, user, fn %{data: %{"id" => object_id}}, user ->
	{:ok, updated} = User.add_pinned_object_id(user, object_id)
	updated
	end)

	%{nickname: nickname, featured_address: featured_address, pinned_objects: pinned_objects} =
	refresh_record(user)

	%{"id" => ^featured_address, "orderedItems" => items, "totalItems" => 2} =
	conn
	\|> get("/users/#{nickname}/collections/featured")
	\|> json_response(200)

	object_ids = Enum.map(items, & &1["id"])

	assert Enum.all?(pinned_objects, fn {obj_id, _} ->
	obj_id in object_ids
	end)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_attachments_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_attachments_test.exs
	new file mode 100644
	index 000000000..9d15974fc
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_attachments_test.exs
	@@ -0,0 +1,98 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunAttachmentsTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_data!(data) do
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ rel_path
	+ \|> File.read!()
	+ \|> Jason.decode!()
	+ \|> ingest_data!()
	+ end
	+
	+ test "drops non-http(s) attachment href" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/attachment_payto_link.json")
	+ assert object.data["attachment"] == []
	+ end
	+
	+ test "drops embedded non-attachment objects" do
	+ {_activity, object} =
	+ ingest_fixture!("test/fixtures/fedidev.fun/attachment_embedded_note.json")
	+
	+ assert object.data["attachment"] == []
	+ end
	+
	+ test "accepts attachment url as list and keeps the first link" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/attachment_url_list.json")
	+
	+ [attachment] = object.data["attachment"]
	+ [%{"href" => href} \| _] = attachment["url"]
	+
	+ assert href == "https://fedidev.fun/images/007.png"
	+ end
	+
	+ test "drops malformed attachment list entries" do
	+ data = File.read!("test/fixtures/fedidev.fun/attachment_url_list.json") \|> Jason.decode!()
	+ data = update_in(data, ["object", "attachment"], &["malformed" \| List.wrap(&1)])
	+
	+ {_activity, object} = ingest_data!(data)
	+
	+ assert length(object.data["attachment"]) == 1
	+ end
	+
	+ test "accepts a URI string in an attachment url list" do
	+ data = File.read!("test/fixtures/fedidev.fun/attachment_url_list.json") \|> Jason.decode!()
	+
	+ data =
	+ put_in(data, ["object", "attachment", "url"], [
	+ "https://fedidev.fun/images/007.png"
	+ ])
	+
	+ {_activity, object} = ingest_data!(data)
	+
	+ assert [%{"url" => [%{"href" => "https://fedidev.fun/images/007.png"}]}] =
	+ object.data["attachment"]
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_emoji_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_emoji_test.exs
	new file mode 100644
	index 000000000..62e30f5af
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_emoji_test.exs
	@@ -0,0 +1,103 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunEmojiTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_data!(data) do
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ rel_path
	+ \|> File.read!()
	+ \|> Jason.decode!()
	+ \|> ingest_data!()
	+ end
	+
	+ test "ingests Emoji tag with string icon" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/emoji_icon_string.json")
	+ assert object.data["emoji"]["cow"] == "https://fedidev.fun/static/cow.png"
	+ end
	+
	+ test "ingests Emoji tag with icon missing type" do
	+ {_activity, object} =
	+ ingest_fixture!("test/fixtures/fedidev.fun/emoji_icon_url_missing_type.json")
	+
	+ assert object.data["emoji"]["cow2"] == "https://fedidev.fun/static/cow.png"
	+ end
	+
	+ test "ignores Emoji tag missing icon" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/emoji_missing_icon.json")
	+ assert object.data["emoji"] == %{}
	+ end
	+
	+ test "ignores Emoji tag missing a string name" do
	+ data = File.read!("test/fixtures/fedidev.fun/emoji_icon_string.json") \|> Jason.decode!()
	+ data = put_in(data, ["object", "tag", Access.at(0), "name"], nil)
	+
	+ {_activity, object} = ingest_data!(data)
	+
	+ assert object.data["emoji"] == %{}
	+ end
	+
	+ test "ignores Emoji tag with a non-http icon" do
	+ data = File.read!("test/fixtures/fedidev.fun/emoji_icon_string.json") \|> Jason.decode!()
	+ data = put_in(data, ["object", "tag", Access.at(0), "icon"], "file:///tmp/cow.png")
	+
	+ {_activity, object} = ingest_data!(data)
	+
	+ assert object.data["emoji"] == %{}
	+ end
	+
	+ test "normalizes a list-typed Emoji tag before building the emoji map" do
	+ data = File.read!("test/fixtures/fedidev.fun/emoji_icon_string.json") \|> Jason.decode!()
	+
	+ data =
	+ put_in(data, ["object", "tag", Access.at(0), "type"], [
	+ "https://example.com/ns#CustomTag",
	+ "Emoji"
	+ ])
	+
	+ {_activity, object} = ingest_data!(data)
	+
	+ assert object.data["emoji"]["cow"] == "https://fedidev.fun/static/cow.png"
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_in_reply_to_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_in_reply_to_test.exs
	new file mode 100644
	index 000000000..b720a5441
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_in_reply_to_test.exs
	@@ -0,0 +1,72 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunInReplyToTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ data = rel_path \|> File.read!() \|> Jason.decode!()
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ test "normalizes Link inReplyTo to a string" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/in_reply_to_link.json")
	+ assert object.data["inReplyTo"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+
	+ test "normalizes list inReplyTo to the first object ID" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/in_reply_to_list.json")
	+ assert object.data["inReplyTo"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+
	+ test "drops invalid map shapes in inReplyTo" do
	+ {_activity, object} =
	+ ingest_fixture!("test/fixtures/fedidev.fun/in_reply_to_collection.json")
	+
	+ assert object.data["inReplyTo"] == nil
	+ end
	+
	+ test "accepts embedded objects in inReplyTo" do
	+ {_activity, object} =
	+ ingest_fixture!("test/fixtures/fedidev.fun/in_reply_to_embedded_note.json")
	+
	+ assert object.data["inReplyTo"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_missing_attributed_to_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_missing_attributed_to_test.exs
	new file mode 100644
	index 000000000..c08e20fc9
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_missing_attributed_to_test.exs
	@@ -0,0 +1,49 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunMissingAttributedToTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ test "inherits attributedTo from surrounding activity" do
	+ data = File.read!("test/fixtures/fedidev.fun/missing_attributed_to.json") \|> Jason.decode!()
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ assert object.data["attributedTo"] == data["actor"]
	+ assert object.data["actor"] == data["actor"]
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_object_type_list_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_object_type_list_test.exs
	new file mode 100644
	index 000000000..b169dc181
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_object_type_list_test.exs
	@@ -0,0 +1,64 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunObjectTypeListTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ data = rel_path \|> File.read!() \|> Jason.decode!()
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ test "accepts object type as a list and stores the first type" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/object_type_list.json")
	+ assert object.data["type"] == "Note"
	+ end
	+
	+ test "selects a supported type after an extension type" do
	+ data = File.read!("test/fixtures/fedidev.fun/object_type_list.json") \|> Jason.decode!()
	+ data = put_in(data, ["object", "type"], ["https://example.com/ns#CustomType", "Note"])
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ assert object.data["type"] == "Note"
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_quote_url_list_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_quote_url_list_test.exs
	new file mode 100644
	index 000000000..9607fabdd
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_quote_url_list_test.exs
	@@ -0,0 +1,63 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunQuoteUrlListTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ data = rel_path \|> File.read!() \|> Jason.decode!()
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ test "normalizes quoteUri list to the first object ID" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/quote_uri_list.json")
	+ assert object.data["quoteUrl"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+
	+ test "normalizes quoteUrl list to the first object ID" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/quote_url_list.json")
	+ assert object.data["quoteUrl"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+
	+ test "normalizes _misskey_quote list to the first object ID" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/misskey_quote_list.json")
	+ assert object.data["quoteUrl"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_tag_inference_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_tag_inference_test.exs
	new file mode 100644
	index 000000000..0650dd38c
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_tag_inference_test.exs
	@@ -0,0 +1,112 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunTagInferenceTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ data = rel_path \|> File.read!() \|> Jason.decode!()
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ test "infers Hashtag type when missing" do
	+ {_activity, object} =
	+ ingest_fixture!("test/fixtures/fedidev.fun/tag_hashtag_missing_type.json")
	+
	+ assert "test" in Object.hashtags(object)
	+ end
	+
	+ test "infers Mention type when missing" do
	+ {_activity, object} =
	+ ingest_fixture!("test/fixtures/fedidev.fun/tag_mention_missing_type.json")
	+
	+ assert Enum.any?(object.data["tag"], fn
	+ %{"type" => "Mention", "href" => "https://remote.example/users/bob"} -> true
	+ _ -> false
	+ end)
	+ end
	+
	+ test "normalizes a list-typed tag type" do
	+ data =
	+ File.read!("test/fixtures/fedidev.fun/tag_hashtag_missing_type.json") \|> Jason.decode!()
	+
	+ data = put_in(data, ["object", "tag", Access.at(0), "type"], ["Hashtag"])
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ assert "test" in Object.hashtags(object)
	+ end
	+
	+ test "ignores a list-typed Hashtag without a string name" do
	+ data =
	+ File.read!("test/fixtures/fedidev.fun/tag_hashtag_missing_type.json") \|> Jason.decode!()
	+
	+ data = put_in(data, ["object", "tag", Access.at(0), "type"], ["Hashtag"])
	+ data = put_in(data, ["object", "tag", Access.at(0), "name"], nil)
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ assert Object.hashtags(object) == []
	+ end
	+
	+ test "infers a Link before deriving quoteUrl" do
	+ data =
	+ File.read!("test/fixtures/fedidev.fun/tag_hashtag_missing_type.json") \|> Jason.decode!()
	+
	+ data =
	+ put_in(data, ["object", "tag"], [
	+ %{
	+ "href" => "https://fedidev.fun/assets/note1.jsonap",
	+ "mediaType" => "application/activity+json"
	+ }
	+ ])
	+
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ assert object.data["quoteUrl"] == "https://fedidev.fun/assets/note1.jsonap"
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_url_list_test.exs b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_url_list_test.exs
	new file mode 100644
	index 000000000..bc084a622
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/transmogrifier/fedidev_fun_url_list_test.exs
	@@ -0,0 +1,53 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FedidevFunUrlListTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+
	+ import Pleroma.Factory
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ defp ensure_remote_actor!(ap_id) when is_binary(ap_id) do
	+ case User.get_cached_by_ap_id(ap_id) do
	+ %User{} ->
	+ :ok
	+
	+ _ ->
	+ insert(:user,
	+ local: false,
	+ ap_id: ap_id,
	+ follower_address: ap_id <> "/followers",
	+ following_address: ap_id <> "/following",
	+ featured_address: ap_id <> "/collections/featured",
	+ inbox: ap_id <> "/inbox"
	+ )
	+
	+ :ok
	+ end
	+ end
	+
	+ defp ingest_fixture!(rel_path) do
	+ data = rel_path \|> File.read!() \|> Jason.decode!()
	+ ensure_remote_actor!(data["actor"])
	+
	+ assert {:ok, activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity.data["object"], fetch: false)
	+
	+ {activity, object}
	+ end
	+
	+ test "normalizes object url list to a string" do
	+ {_activity, object} = ingest_fixture!("test/fixtures/fedidev.fun/url_list.json")
	+ assert object.data["url"] == "https://fedidev.fun/objects/123"
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	index 31b9a699d..793293abd 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	@@ -1,796 +1,822 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :max_remote_account_fields])

	describe "handle_incoming" do
	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert "test" in Object.tags(object)
	assert Object.hashtags(object) == ["test"]
	end

	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", Object.normalize(activity, fetch: false).data)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	test "it fetches reply-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://mstdn.io/users/mayuutann/statuses/99568293732299394")

	data = Map.put(data, "object", object)
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)
	returned_object = Object.normalize(returned_activity, fetch: false)

	assert %Activity{} =
	Activity.get_create_by_object_ap_id(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)

	assert returned_object.data["inReplyTo"] ==
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	end

	test "it does not fetch reply-to activities beyond max replies depth limit" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data = Map.put(data, "object", object)

	with_mock Pleroma.Web.Federator,
	allowed_thread_distance?: fn _ -> false end do
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	returned_object = Object.normalize(returned_activity, fetch: false)

	refute Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_object.data["inReplyTo"] == "https://shitposter.club/notice/2827873"
	end
	end

	test "it does not crash if the object in inReplyTo can't be fetched" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://404.site/whatever")

	data =
	data
	\|> Map.put("object", object)

	assert {:ok, _returned_activity} = Transmogrifier.handle_incoming(data)
	end

	test "it does not work for deactivated users" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	insert(:user, ap_id: data["actor"], is_active: false)

	assert {:error, _} = Transmogrifier.handle_incoming(data)
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://localtesting.pleroma.lol/users/lain",
	"http://mastodon.example.org/users/admin/followers"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object_data = Object.normalize(data["object"], fetch: false).data

	assert object_data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object_data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object_data["cc"] == [
	"http://localtesting.pleroma.lol/users/lain",
	"http://mastodon.example.org/users/admin/followers"
	]

	assert object_data["actor"] == "http://mastodon.example.org/users/admin"
	assert object_data["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object_data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object_data["sensitive"] == true

	user = User.get_cached_by_ap_id(object_data["actor"])

	assert user.note_count == 1
	end

	test "it works for incoming notices without the sensitive property but an nsfw hashtag" do
	data = File.read!("test/fixtures/mastodon-post-activity-nsfw.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	object_data = Object.normalize(data["object"], fetch: false).data

	assert object_data["sensitive"] == true
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert match?(
	%{
	"href" => "http://localtesting.pleroma.lol/users/lain",
	"name" => "@lain@localtesting.pleroma.lol",
	"type" => "Mention"
	},
	Enum.at(object.data["tag"], 0)
	)

	assert match?(
	%{
	"href" => "http://mastodon.example.org/tags/moo",
	"name" => "#moo",
	"type" => "Hashtag"
	},
	Enum.at(object.data["tag"], 1)
	)

	assert "moo" == Enum.at(object.data["tag"], 2)
	end

	test "it works for incoming notices with contentMap" do
	data = File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it only uses contentMap if content is not present" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Hi",
	"contentMap" => %{
	"de" => "Hallo",
	"uk" => "Привіт"
	},
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(message)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["content"] == "Hi"
	end

	test "it works for incoming notices with a nil contentMap (firefish)" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json")
	\|> Jason.decode!()
	\|> Map.put("contentMap", nil)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("cc", nil)

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("cc", nil)
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	refute is_nil(data["cc"])
	end

	test "it strips internal likes" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	likes = %{
	"first" =>
	"http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
	"id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
	"totalItems" => 3,
	"type" => "OrderedCollection"
	}

	object = Map.put(data["object"], "likes", likes)
	data = Map.put(data, "object", object)

	{:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity)

	assert object.data["likes"] == []
	end

	test "it strips internal reactions" do
	user = insert(:user)
	{: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)
	assert Map.has_key?(object.data, "reactions")
	assert Map.has_key?(object.data, "reaction_count")

	object_data = Transmogrifier.strip_internal_fields(object.data)
	refute Map.has_key?(object_data, "reactions")
	refute Map.has_key?(object_data, "reaction_count")
	end

	test "it correctly processes messages with non-array to field" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("to", "https://www.w3.org/ns/activitystreams#Public")
	\|> put_in(["object", "to"], "https://www.w3.org/ns/activitystreams#Public")

	assert {:ok, activity} = Transmogrifier.handle_incoming(data)

	assert [
	"http://localtesting.pleroma.lol/users/lain",
	"http://mastodon.example.org/users/admin/followers"
	] == activity.data["cc"]

	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with non-array cc field" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("cc", "http://mastodon.example.org/users/admin/followers")
	\|> put_in(["object", "cc"], "http://mastodon.example.org/users/admin/followers")

	assert {:ok, activity} = Transmogrifier.handle_incoming(data)

	assert ["http://mastodon.example.org/users/admin/followers"] == activity.data["cc"]
	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with weirdness in address fields" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("cc", ["http://mastodon.example.org/users/admin/followers", ["¿"]])
	\|> put_in(["object", "cc"], ["http://mastodon.example.org/users/admin/followers", ["¿"]])

	assert {:ok, activity} = Transmogrifier.handle_incoming(data)

	assert ["http://mastodon.example.org/users/admin/followers"] == activity.data["cc"]
	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end
	end

	describe "`handle_incoming/2`, Mastodon format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	items = get_in(data, ["object", "replies", "first", "items"])
	assert length(items) > 0

	%{data: data, items: items}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	data: data,
	items: items
	} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 10)

	{:ok, activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity.data["object"])

	assert object.data["replies"] == items

	for id <- items do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{data: data} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	{:ok, _activity} = Transmogrifier.handle_incoming(data)

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "`handle_incoming/2`, Pleroma format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	replies = %{
	"type" => "Collection",
	"items" => [Utils.generate_object_id(), Utils.generate_object_id()]
	}

	activity =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["object", "replies"], replies)

	%{activity: activity}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	activity: activity
	} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 1)

	assert {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(data["object"])

	for id <- object.data["replies"] do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{activity: activity} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	{:ok, _activity} = Transmogrifier.handle_incoming(activity)

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_activity(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_activity(activity.data)
	end
	end

	describe "fix_in_reply_to/2" do
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	[data: data]
	end

	test "returns not modified object when has no inReplyTo field", %{data: data} do
	assert Transmogrifier.fix_in_reply_to(data) == data
	end

	test "returns object with inReplyTo when denied incoming reply", %{data: data} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	object_with_reply =
	Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873")

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == "https://shitposter.club/notice/2827873"

	object_with_reply =
	Map.put(data["object"], "inReplyTo", %{"id" => "https://shitposter.club/notice/2827873"})

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == %{"id" => "https://shitposter.club/notice/2827873"}

	object_with_reply =
	Map.put(data["object"], "inReplyTo", ["https://shitposter.club/notice/2827873"])

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	- assert modified_object["inReplyTo"] == ["https://shitposter.club/notice/2827873"]
	+ assert modified_object["inReplyTo"] == "https://shitposter.club/notice/2827873"

	object_with_reply = Map.put(data["object"], "inReplyTo", [])
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	- assert modified_object["inReplyTo"] == []
	+ assert modified_object["inReplyTo"] == nil
	end

	test "returns modified object when allowed incoming reply", %{data: data} do
	object_with_reply =
	Map.put(
	data["object"],
	"inReplyTo",
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)

	clear_config([:instance, :federation_incoming_replies_max_depth], 5)
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)

	assert modified_object["inReplyTo"] ==
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"

	assert modified_object["context"] ==
	"tag:shitposter.club,2018-02-22:objectType=thread:nonce=e5a7c72d60a9c0e4"
	end
	end

	describe "fix_attachments/1" do
	test "returns not modified object" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_attachments(data) == data
	end

	test "returns modified object when attachment is map" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => %{
	"mediaType" => "video/mp4",
	"url" => "https://peertube.moe/stat-480.mp4"
	}
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"type" => "Document",
	"url" => [
	%{
	"href" => "https://peertube.moe/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end

	test "returns modified object when attachment is list" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => [
	%{"mediaType" => "video/mp4", "url" => "https://pe.er/stat-480.mp4"},
	%{"mimeType" => "video/mp4", "href" => "https://pe.er/stat-480.mp4"}
	]
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"type" => "Document",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	},
	%{
	"mediaType" => "video/mp4",
	"type" => "Document",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end
	end

	describe "fix_emoji/1" do
	test "returns not modified object when object not contains tags" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_emoji(data) == data
	end

	test "returns object with emoji when object contains list tags" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => [
	- %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}},
	+ %{
	+ "type" => "Emoji",
	+ "name" => ":bib:",
	+ "icon" => %{"url" => "https://example.com/test"}
	+ },
	%{"type" => "Hashtag"}
	]
	}) == %{
	- "emoji" => %{"bib" => "/test"},
	+ "emoji" => %{"bib" => "https://example.com/test"},
	"tag" => [
	- %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"},
	+ %{
	+ "icon" => %{"url" => "https://example.com/test"},
	+ "name" => ":bib:",
	+ "type" => "Emoji"
	+ },
	%{"type" => "Hashtag"}
	]
	}
	end

	test "returns object with emoji when object contains map tag" do
	assert Transmogrifier.fix_emoji(%{
	- "tag" => %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}}
	+ "tag" => %{
	+ "type" => "Emoji",
	+ "name" => ":bib:",
	+ "icon" => %{"url" => "https://example.com/test"}
	+ }
	}) == %{
	- "emoji" => %{"bib" => "/test"},
	- "tag" => %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"}
	+ "emoji" => %{"bib" => "https://example.com/test"},
	+ "tag" => %{
	+ "icon" => %{"url" => "https://example.com/test"},
	+ "name" => ":bib:",
	+ "type" => "Emoji"
	+ }
	+ }
	+ end
	+ end
	+
	+ describe "fix_tag/1" do
	+ test "ignores malformed Hashtag names and tag entries" do
	+ tag = %{"type" => "Hashtag", "name" => 123}
	+
	+ assert Transmogrifier.fix_tag(%{"tag" => [tag, "malformed"]}) == %{
	+ "tag" => [tag, "malformed"]
	}
	end
	end

	describe "set_replies/1" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 2)

	test "still provides reply collection id even if activity doesn't have replies yet" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	object = data["object"] \|> Map.delete("replies")
	modified = Transmogrifier.set_replies(object)

	refute object["replies"]
	assert modified["replies"]
	assert match?(%{"id" => "http" <> _, "totalItems" => 0}, modified["replies"])
	# first page should be omitted if there are no entries anyway
	refute modified["replies"]["first"]
	end

	test "sets `replies` collection with a limited number of replies, preferring oldest" do
	[user, another_user] = insert_list(2, :user)

	{: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})

	{:ok, self_reply2} =
	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 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
	})

	object = Object.normalize(activity, fetch: false)
	replies_uris = Enum.map([self_reply1, self_reply2], fn a -> a.object.data["id"] end)

	assert %{"type" => "OrderedCollection", "first" => %{"orderedItems" => ^replies_uris}} =
	Transmogrifier.set_replies(object.data)["replies"]
	end
	end

	test "take_emoji_tags/1" do
	user = insert(:user, %{emoji: %{"firefox" => "https://example.org/firefox.png"}})

	assert Transmogrifier.take_emoji_tags(user) == [
	%{
	"icon" => %{"type" => "Image", "url" => "https://example.org/firefox.png"},
	"id" => "https://example.org/firefox.png",
	"name" => ":firefox:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	end

	test "the standalone note uses its own ID when context is missing" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")

	activity =
	"test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	{:ok, %Activity{} = modified} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(modified, fetch: false)

	assert object.data["context"] == object.data["id"]
	assert modified.data["context"] == object.data["id"]
	end

	test "the reply note uses its parent's ID when context is missing and reply is unreachable" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")

	activity =
	"test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	object =
	activity["object"]
	\|> Map.put("inReplyTo", "https://404.site/object/went-to-buy-milk")

	activity =
	activity
	\|> Map.put("object", object)

	{:ok, %Activity{} = modified} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(modified, fetch: false)

	assert object.data["context"] == object.data["inReplyTo"]
	assert modified.data["context"] == object.data["inReplyTo"]
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	index 851c60850..cf995e143 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	@@ -1,159 +1,178 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.UserUpdateHandlingTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

	test "it works for incoming update activities" do
	user = insert(:user, local: false)

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	assert data["id"] == update_data["id"]

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	+ test "it selects an actor type after an extension type" do
	+ user = insert(:user, local: false)
	+ update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()
	+
	+ object =
	+ update_data["object"]
	+ \|> Map.put("actor", user.ap_id)
	+ \|> Map.put("id", user.ap_id)
	+ \|> Map.put("type", ["https://example.com/ns#CustomActor", "Person"])
	+
	+ update_data =
	+ update_data
	+ \|> Map.put("actor", user.ap_id)
	+ \|> Map.put("object", object)
	+
	+ assert {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(update_data)
	+ assert User.get_cached_by_ap_id(user.ap_id).name == "gargle"
	+ end
	+
	test "it works with alsoKnownAs" do
	%{ap_id: actor} = insert(:user, local: false)

	assert User.get_cached_by_ap_id(actor).also_known_as == []

	{:ok, _activity} =
	"test/fixtures/mastodon-update.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> Map.put("actor", actor)
	\|> Map.update!("object", fn object ->
	object
	\|> Map.put("actor", actor)
	\|> Map.put("id", actor)
	\|> Map.put("alsoKnownAs", [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	])
	end)
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	]
	end

	test "it works with custom profile fields" do
	user = insert(:user, local: false)

	assert user.fields == []

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	clear_config([:instance, :max_remote_account_fields], 2)

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [
	%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
	%{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
	%{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
	])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "foo11", "value" => "bar11"}
	]

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == []
	end

	test "it works for incoming update activities which lock the account" do
	user = insert(:user, local: false)

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.is_locked == true
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 8:49 AM (8 h, 45 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803980
Default Alt Text: (281 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions