No OneTemporary
Actions

Size

759 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/pipeline-application-on-create.fix b/changelog.d/pipeline-application-on-create.fix
	new file mode 100644
	index 000000000..49a7710ab
	--- /dev/null
	+++ b/changelog.d/pipeline-application-on-create.fix
	@@ -0,0 +1 @@
	+The `application` field is now present in the response of `POST /api/v1/statuses` and in status previews.
	diff --git a/changelog.d/pipeline-local-posts.change b/changelog.d/pipeline-local-posts.change
	new file mode 100644
	index 000000000..62a4710ee
	--- /dev/null
	+++ b/changelog.d/pipeline-local-posts.change
	@@ -0,0 +1 @@
	+Local posts are now created through the ActivityPub pipeline (validation, MRF, side effects, federation) like every other activity. Hashtags of local posts are stored as ActivityStreams `Hashtag` tags, and replies and quotes only count public and unlisted posts for remote posts too.
	diff --git a/lib/pleroma/constants.ex b/lib/pleroma/constants.ex
	index 178dd6094..7187006ce 100644
	--- a/lib/pleroma/constants.ex
	+++ b/lib/pleroma/constants.ex
	@@ -1,160 +1,161 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Constants do
	use Const

	const(as_public, do: "https://www.w3.org/ns/activitystreams#Public")

	const(object_internal_fields,
	do: [
	"reactions",
	"reaction_count",
	"likes",
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id",
	"deleted_activity_id",
	"pleroma_internal",
	"generator",
	"rules",
	"language",
	"voters",
	- "assigned_account"
	+ "assigned_account",
	+ "listMessage"
	]
	)

	const(static_only_files,
	do:
	~w(index.html robots.txt static static-fe finmoji emoji packs sounds images instance sw.js sw-pleroma.js schemas doc embed.js embed.css)
	)

	const(status_updatable_fields,
	do: [
	"source",
	"tag",
	"updated",
	"emoji",
	"content",
	"contentMap",
	"summary",
	"sensitive",
	"attachment",
	"generator",
	"language"
	]
	)

	const(status_object_types,
	do: [
	"Note",
	"Question",
	"Audio",
	"Video",
	"Event",
	"Article",
	"Page"
	]
	)

	const(updatable_object_types,
	do: [
	"Note",
	"Question",
	"Audio",
	"Video",
	"Event",
	"Article",
	"Page"
	]
	)

	const(actor_types,
	do: [
	"Application",
	"Group",
	"Organization",
	"Person",
	"Service"
	]
	)

	const(allowed_user_actor_types,
	do: [
	"Person",
	"Service",
	"Group"
	]
	)

	const(activity_types,
	do: [
	"Block",
	"Create",
	"Update",
	"Delete",
	"Follow",
	"Accept",
	"Reject",
	"Add",
	"Remove",
	"Like",
	"Dislike",
	"Announce",
	"Undo",
	"Flag",
	"EmojiReact",
	"Listen"
	]
	)

	const(allowed_activity_types_from_strangers,
	do: [
	"Block",
	"Create",
	"Flag",
	"Follow",
	"Like",
	"Dislike",
	"EmojiReact",
	"Announce"
	]
	)

	const(object_types,
	do: ~w[Event Question Answer Audio Video Image Article Note Page ChatMessage]
	)

	# basic regex, just there to weed out potential mistakes
	# https://datatracker.ietf.org/doc/html/rfc2045#section-5.1
	const(mime_regex,
	do: ~r/^[^[:cntrl:] ()<>@,;:\\"\/\[\]?=]+\/[^[:cntrl:] ()<>@,;:\\"\/\[\]?=]+(; .*)?$/
	)

	# List of allowed chars in the path segment of a URI
	# unreserved, sub-delims, ":", "@" and "/" allowed as the separator in path
	# https://datatracker.ietf.org/doc/html/rfc3986
	const(uri_path_allowed_reserved_chars,
	do: ~c"!$&'()*+,;=/:@"
	)

	const(upload_object_types, do: ["Document", "Image"])

	const(activity_json_canonical_mime_type,
	do: "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)

	const(activity_json_mime_types,
	do: [
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"application/activity+json"
	]
	)

	const(public_streams,
	do: ["public", "public:local", "public:media", "public:local:media"]
	)
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 1279e0cb4..92e0020f3 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,2106 +1,2040 @@
	# 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.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Hashtag
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker
	- alias Pleroma.Workers.PollWorker

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility
	import Pleroma.Webhook.Notify, only: [trigger_webhooks: 2]

	require Logger
	require Pleroma.Constants

	@behaviour Pleroma.Web.ActivityPub.ActivityPub.Persisting
	@behaviour Pleroma.Web.ActivityPub.ActivityPub.Streaming

	defp get_recipients(%{"type" => "Create"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = Map.get(data, "actor", [])
	recipients = [to, cc, bcc, [actor]] \|> Enum.concat() \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	recipients = Enum.concat([to, cc, bcc])
	{recipients, to, cc}
	end

	defp check_actor_can_insert(%{"type" => "Delete"}), do: true
	defp check_actor_can_insert(%{"type" => "Undo"}), do: true

	defp check_actor_can_insert(%{"actor" => actor}) when is_binary(actor) do
	case User.get_cached_by_ap_id(actor) do
	%User{is_active: true} -> true
	_ -> false
	end
	end

	defp check_actor_can_insert(_), do: true

	defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
	limit = Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	def increase_note_count_if_public(actor, object) do
	if public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
	end

	def decrease_note_count_if_public(actor, object) do
	if public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
	end

	def update_last_status_at_if_public(actor, object) do
	if public?(object), do: User.update_last_status_at(actor), else: {:ok, actor}
	end

	- defp increase_replies_count_if_reply(%{
	- "object" => %{"inReplyTo" => reply_ap_id} = object,
	- "type" => "Create"
	- }) do
	- if public?(object) do
	- Object.increase_replies_count(reply_ap_id)
	- end
	- end
	-
	- defp increase_replies_count_if_reply(_create_data), do: :noop
	-
	- defp increase_quotes_count_if_quote(%{
	- "object" => %{"quoteUrl" => quote_ap_id} = object,
	- "type" => "Create"
	- }) do
	- if public?(object) do
	- Object.increase_quotes_count(quote_ap_id)
	- end
	- end
	-
	- defp increase_quotes_count_if_quote(_create_data), do: :noop
	-
	@object_types ~w[ChatMessage Question Answer Audio Video Image Event Article Note Page]
	@impl true
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

	@impl true
	def persist(object, meta) do
	with local <- Keyword.fetch!(meta, :local),
	{recipients, _, _} <- get_recipients(object),
	{:ok, activity} <-
	Repo.insert(%Activity{
	data: object,
	local: local,
	recipients: recipients,
	actor: object["actor"]
	}),
	- # TODO: add tests for expired activities, when Note type will be supported in new pipeline
	{:ok, _} <- maybe_create_activity_expiration(activity) do
	{:ok, activity, meta}
	end
	end

	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	{_, true} <- {:actor_check, bypass_actor_check \|\| check_actor_can_insert(map)},
	{_, true} <- {:remote_limit_pass, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map),
	{:ok, activity} <- insert_activity_with_expiration(map, local, recipients) do
	# Splice in the child object if we have one.
	activity = Maps.put_if_present(activity, :object, object)

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)

	# Add local posts to search index
	if local, do: Pleroma.Search.add_to_index(activity)

	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:actor_check, _} ->
	{:error, false}

	{:containment, _} = error ->
	error

	{:error, _} = error ->
	error

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)
	{:ok, activity}

	{:remote_limit_pass, _} ->
	{:error, :remote_limit}

	{:reject, _} = e ->
	{:error, e}
	end
	end

	defp insert_activity_with_expiration(data, local, recipients) do
	struct = %Activity{
	data: data,
	local: local,
	actor: data["actor"],
	recipients: recipients
	}

	with {:ok, activity} <- Repo.insert(struct) do
	maybe_create_activity_expiration(activity)
	end
	end

	def notify_and_stream(activity) do
	{:ok, notifications} = Notification.create_notifications(activity)
	Notification.stream(notifications)

	original_activity =
	case activity do
	%{data: %{"type" => "Update"}, object: %{data: %{"id" => id}}} ->
	Activity.get_create_by_object_ap_id_with_object(id)

	_ ->
	activity
	end

	conversation = create_or_bump_conversation(original_activity, original_activity.actor)
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	end

	defp maybe_create_activity_expiration(
	%{data: %{"expires_at" => %DateTime{} = expires_at}} = activity
	) do
	with {:ok, _job} <-
	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: activity.id
	},
	scheduled_at: expires_at
	) do
	{:ok, activity}
	end
	end

	+ defp maybe_create_activity_expiration(%{data: %{"expires_at" => expires_at}} = activity)
	+ when is_binary(expires_at) do
	+ with {:ok, expires_at, _} <- DateTime.from_iso8601(expires_at) do
	+ maybe_create_activity_expiration(put_in(activity.data["expires_at"], expires_at))
	+ end
	+ end
	+
	defp maybe_create_activity_expiration(activity), do: {:ok, activity}

	defp create_or_bump_conversation(activity, actor) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	Participation.mark_as_read(user, conversation)
	{:ok, conversation}
	end
	end

	defp get_participations({:ok, conversation}) do
	conversation
	\|> Repo.preload(:participations, force: true)
	\|> Map.get(:participations)
	end

	defp get_participations(_), do: []

	def stream_out_participations(participations) do
	participations =
	participations
	\|> Repo.preload(:user)

	Streamer.stream("participation", participations)
	end

	@impl true
	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context) do
	conversation = Repo.preload(conversation, :participations)

	last_activity_id =
	fetch_latest_direct_activity_id_for_context(conversation.ap_id, %{
	user: user,
	blocking_user: user
	})

	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	@impl true
	def stream_out_participations(_, _), do: :noop

	@impl true
	def stream_out(%Activity{data: %{"type" => data_type}} = activity)
	when data_type in ["Create", "Announce", "Delete", "Update"] do
	activity
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(activity)
	end

	@impl true
	def stream_out(_activity) do
	:noop
	end

	- @spec create(map(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	- def create(params, fake \\ false) do
	- with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
	- result
	- end
	- end
	-
	- defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	- additional = params[:additional] \|\| %{}
	- # only accept false as false value
	- local = !(params[:local] == false)
	- published = params[:published]
	- quick_insert? = Config.get([:env]) == :benchmark
	-
	- create_data =
	- make_create_data(
	- %{to: to, actor: actor, published: published, context: context, object: object},
	- additional
	- )
	-
	- with {:ok, activity} <- insert(create_data, local, fake),
	- {:fake, false, activity} <- {:fake, fake, activity},
	- _ <- increase_replies_count_if_reply(create_data),
	- _ <- increase_quotes_count_if_quote(create_data),
	- {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	- {:ok, _actor} <- increase_note_count_if_public(actor, activity),
	- {:ok, _actor} <- update_last_status_at_if_public(actor, activity),
	- _ <- notify_and_stream(activity),
	- :ok <- maybe_schedule_poll_notifications(activity),
	- :ok <- maybe_handle_group_posts(activity),
	- :ok <- maybe_federate(activity) do
	- {:ok, activity}
	- else
	- {:quick_insert, true, activity} ->
	- {:ok, activity}
	-
	- {:fake, true, activity} ->
	- {:ok, activity}
	-
	- {:error, message} ->
	- Repo.rollback(message)
	- end
	- end
	-
	- defp maybe_schedule_poll_notifications(activity) do
	- PollWorker.schedule_poll_end(activity)
	- :ok
	- end
	-
	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	listen_data =
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(listen_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec unfollow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| nil \| {:error, any()}
	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_unfollow(follower, followed, activity_id, local) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def flag(params) do
	with {:ok, result} <- Repo.transaction(fn -> do_flag(params) end) do
	result
	end
	end

	defp do_flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	_ <- notify_and_stream(activity),
	_ <- trigger_webhooks(activity, :"report.created"),
	:ok <-
	maybe_federate(activity) do
	User.all_users_with_privilege(:reports_manage_reports)
	\|> Enum.filter(fn user -> user.ap_id != actor end)
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn privileged_user ->
	privileged_user
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id,
	"to" => [origin.follower_address]
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local),
	_ <- notify_and_stream(activity) do
	maybe_federate(activity)

	BackgroundWorker.new(%{
	"op" => "move_following",
	"origin_id" => origin.id,
	"target_id" => target.id
	})
	\|> Oban.insert()

	{:ok, activity}
	else
	false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
	err -> err
	end
	end

	def fetch_activities_for_context_query(context, opts) do
	public = [Constants.as_public()]

	recipients =
	if opts[:user],
	do: [opts[:user].ap_id \| User.following(opts[:user])] ++ public,
	else: public

	from(activity in Activity)
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> restrict_unauthenticated(opts[:user])
	\|> restrict_blocked(opts)
	\|> restrict_blockers_visibility(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_filtered(opts)
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> exclude_poll_votes(opts)
	\|> exclude_id(opts)
	\|> order_by([activity], desc: activity.id)
	end

	@spec fetch_activities_for_context(String.t(), keyword() \| map()) :: [Activity.t()]
	def fetch_activities_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(opts)
	\|> Repo.all()
	end

	def fetch_objects_for_replies_collection(parent_ap_id, opts \\ %{}) do
	opts =
	opts
	\|> Map.put(:order_asc, true)
	\|> Map.put(:id_type, :integer)

	from(o in Object,
	where:
	fragment("?->>'inReplyTo' = ?", o.data, ^parent_ap_id) and
	fragment(
	"(?->'to' \\? ?::text OR ?->'cc' \\? ?::text)",
	o.data,
	^Pleroma.Constants.as_public(),
	o.data,
	^Pleroma.Constants.as_public()
	) and
	fragment("?->>'type' <> 'Answer'", o.data),
	select: %{id: o.id, ap_id: fragment("?->>'id'", o.data)}
	)
	\|> Pagination.fetch_paginated(opts, :keyset)
	end

	@spec fetch_latest_direct_activity_id_for_context(String.t(), keyword() \| map()) ::
	Ecto.UUID.t() \| nil
	def fetch_latest_direct_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{skip_preload: true}, opts))
	\|> restrict_visibility(%{visibility: "direct"})
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	defp fetch_paginated_optimized(query, opts, pagination) do
	# Note: tag-filtering funcs may apply "ORDER BY objects.id DESC",
	# and extra sorting on "activities.id DESC NULLS LAST" would worse the query plan
	opts = Map.put(opts, :skip_extra_order, true)

	Pagination.fetch_paginated(query, opts, pagination, pagination_binding(opts))
	end

	defp pagination_binding(%{favorited_by: _}), do: :favorited_activity
	defp pagination_binding(_), do: nil

	def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
	list_memberships = Pleroma.List.memberships(opts[:user])

	fetch_activities_query(recipients ++ list_memberships, opts)
	\|> fetch_paginated_optimized(opts, pagination)
	\|> Enum.reverse()
	\|> maybe_update_cc(list_memberships, opts[:user])
	end

	@spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
	includes_local_public = Map.get(opts, :includes_local_public, false)

	opts = Map.delete(opts, :user)

	intended_recipients =
	if includes_local_public do
	[Constants.as_public(), as_local_public()]
	else
	[Constants.as_public()]
	end

	intended_recipients
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted(opts)
	\|> fetch_paginated_optimized(opts, pagination)
	end

	@spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts
	\|> Map.put(:restrict_unlisted, true)
	\|> fetch_public_or_unlisted_activities(pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ?",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility not in [nil \| @valid_visibilities] do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{skip_thread_containment: true}}, _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{ap_id: ap_id}}, _) do
	local_public = as_local_public()

	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id', ?) = true", ^ap_id, a.data, ^local_public)
	)
	end

	defp restrict_thread_visibility(query, _, _), do: query

	def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{})

	def fetch_user_activities(user, reading_user, %{total: true} = params) do
	result = fetch_activities_for_user(user, reading_user, params)

	Keyword.put(result, :items, Enum.reverse(result[:items]))
	end

	def fetch_user_activities(user, reading_user, params) do
	user
	\|> fetch_activities_for_user(reading_user, params)
	\|> Enum.reverse()
	end

	defp fetch_activities_for_user(user, reading_user, params) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)
	\|> Map.put(:actor_local, user.local)
	\|> Map.put(:pinned_object_ids, Map.keys(user.pinned_objects))

	params =
	if User.blocks?(reading_user, user) do
	params
	else
	params
	\|> Map.put(:blocking_user, reading_user)
	\|> Map.put(:muting_user, reading_user)
	end

	pagination_type = Map.get(params, :pagination_type) \|\| :keyset

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, pagination_type)
	end

	def fetch_statuses(reading_user, %{total: true} = params) do
	result = fetch_activities_for_reading_user(reading_user, params)
	Keyword.put(result, :items, Enum.reverse(result[:items]))
	end

	def fetch_statuses(reading_user, params) do
	reading_user
	\|> fetch_activities_for_reading_user(params)
	\|> Enum.reverse()
	end

	defp fetch_activities_for_reading_user(reading_user, params) do
	params = Map.put(params, :type, ["Create", "Announce"])

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, :offset)
	end

	defp user_activities_recipients(%{godmode: true}), do: []

	defp user_activities_recipients(%{reading_user: reading_user}) do
	if not is_nil(reading_user) and reading_user.local do
	[
	Constants.as_public(),
	as_local_public(),
	reading_user.ap_id \| User.following(reading_user)
	]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_announce_object_actor(_query, %{announce_filtering_user: _, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_announce_object_actor(query, %{announce_filtering_user: %{ap_id: actor}}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'type' != ? or ?->>'actor' != ?",
	activity.data,
	"Announce",
	object.data,
	^actor
	)
	)
	end

	defp restrict_announce_object_actor(query, _), do: query

	defp restrict_since(query, %{since_id: ""}), do: query

	defp restrict_since(query, %{favorited_by: _, since_id: _}), do: query

	defp restrict_since(query, %{since_id: since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_embedded_tag_all(_query, %{tag_all: _tag_all, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_embedded_tag_all(query, %{tag_all: [_ \| _] = tag_all}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_embedded_tag_all(query, %{tag_all: tag}) when is_binary(tag) do
	restrict_embedded_tag_any(query, %{tag: tag})
	end

	defp restrict_embedded_tag_all(query, _), do: query

	defp restrict_embedded_tag_any(_query, %{tag: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_embedded_tag_any(query, %{tag: [_ \| _] = tag_any}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag_any)
	)
	end

	defp restrict_embedded_tag_any(query, %{tag: tag}) when is_binary(tag) do
	restrict_embedded_tag_any(query, %{tag: [tag]})
	end

	defp restrict_embedded_tag_any(query, _), do: query

	defp restrict_embedded_tag_reject_any(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_embedded_tag_reject_any(query, %{tag_reject: [_ \| _] = tag_reject}) do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_embedded_tag_reject_any(query, %{tag_reject: tag_reject})
	when is_binary(tag_reject) do
	restrict_embedded_tag_reject_any(query, %{tag_reject: [tag_reject]})
	end

	defp restrict_embedded_tag_reject_any(query, _), do: query

	defp object_ids_query_for_tags(tags) do
	from(hto in "hashtags_objects")
	\|> join(:inner, [hto], ht in Pleroma.Hashtag, on: hto.hashtag_id == ht.id)
	\|> where([hto, ht], ht.name in ^tags)
	\|> select([hto], hto.object_id)
	\|> distinct([hto], true)
	end

	defp restrict_hashtag_all(_query, %{tag_all: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_all(query, %{tag_all: [single_tag]}) do
	restrict_hashtag_any(query, %{tag: single_tag})
	end

	defp restrict_hashtag_all(query, %{tag_all: [_ \| _] = tags}) do
	from(
	[_activity, object] in query,
	where:
	fragment(
	"""
	(SELECT array_agg(hashtags.name) FROM hashtags JOIN hashtags_objects
	ON hashtags_objects.hashtag_id = hashtags.id WHERE hashtags.name = ANY(?)
	AND hashtags_objects.object_id = ?) @> ?
	""",
	^tags,
	object.id,
	^tags
	)
	)
	end

	defp restrict_hashtag_all(query, %{tag_all: tag}) when is_binary(tag) do
	restrict_hashtag_all(query, %{tag_all: [tag]})
	end

	defp restrict_hashtag_all(query, _), do: query

	defp restrict_hashtag_any(_query, %{tag: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_any(query, %{tag: [_ \| _] = tags}) do
	hashtag_ids =
	from(ht in Hashtag, where: ht.name in ^tags, select: ht.id)
	\|> Repo.all()

	# Note: NO extra ordering should be done on "activities.id desc nulls last" for optimal plan
	query =
	from(
	[_activity, object] in query,
	join: hto in "hashtags_objects",
	on: hto.object_id == object.id,
	where: hto.hashtag_id in ^hashtag_ids
	)

	if is_nil(query.distinct) do
	from([_activity, object] in query,
	distinct: [desc: object.id],
	order_by: [desc: object.id]
	)
	else
	query
	end
	end

	defp restrict_hashtag_any(query, %{tag: tag}) when is_binary(tag) do
	restrict_hashtag_any(query, %{tag: [tag]})
	end

	defp restrict_hashtag_any(query, _), do: query

	defp restrict_hashtag_reject_any(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_reject_any(query, %{tag_reject: [_ \| _] = tags_reject}) do
	from(
	[_activity, object] in query,
	where: object.id not in subquery(object_ids_query_for_tags(tags_reject))
	)
	end

	defp restrict_hashtag_reject_any(query, %{tag_reject: tag_reject}) when is_binary(tag_reject) do
	restrict_hashtag_reject_any(query, %{tag_reject: [tag_reject]})
	end

	defp restrict_hashtag_reject_any(query, _), do: query

	defp raise_on_missing_preload do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	# Essentially, either look for activities addressed to `recipients`, _OR_ ones
	# that reference a hashtag that the user follows
	# Firstly, two fallbacks in case there's no hashtag constraint, or the user doesn't
	# follow any
	defp restrict_recipients_or_hashtags(query, recipients, user, nil) do
	restrict_recipients(query, recipients, user)
	end

	defp restrict_recipients_or_hashtags(query, recipients, user, []) do
	restrict_recipients(query, recipients, user)
	end

	defp restrict_recipients_or_hashtags(query, recipients, _user, hashtag_ids) do
	from([activity, object] in query)
	\|> join(:left, [activity, object], hto in "hashtags_objects",
	on: hto.object_id == object.id,
	as: :hto
	)
	\|> where(
	[activity, object, hto: hto],
	(hto.hashtag_id in ^hashtag_ids and ^Constants.as_public() in activity.recipients) or
	fragment("? && ?", ^recipients, activity.recipients)
	)
	end

	defp restrict_local(query, %{local_only: true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_remote(query, %{remote: true}) do
	from(activity in query, where: activity.local == false)
	end

	defp restrict_remote(query, _), do: query

	defp restrict_actor(query, %{actor_id: actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{type: type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{type: type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_state(query, %{state: state}) do
	from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
	end

	defp restrict_state(query, _), do: query

	defp restrict_report_target(query, %{report_target_id: actor_id}) do
	from(activity in query,
	where: fragment("?->'object'->>0 = ?", activity.data, ^actor_id)
	)
	end

	defp restrict_report_target(query, _), do: query

	defp restrict_assigned_account(query, %{assigned_account: assigned_account}) do
	from(activity in query,
	where: fragment("?->>'assigned_account' = ?", activity.data, ^assigned_account)
	)
	end

	defp restrict_assigned_account(query, _), do: query

	defp restrict_favorited_by(query, %{favorited_by: ap_id}) do
	newer_favorite =
	from(newer_favorite in Activity,
	where: newer_favorite.actor == ^ap_id,
	where: newer_favorite.id > parent_as(:favorited_activity).id,
	where: fragment("?->>'type' = ?", newer_favorite.data, "Like"),
	where:
	fragment(
	"associated_object_id(?) = associated_object_id(?)",
	newer_favorite.data,
	parent_as(:favorited_activity).data
	),
	select: 1
	)

	from(
	[activity, object: object] in query,
	join: favorited_activity in Activity,
	as: :favorited_activity,
	on:
	favorited_activity.actor == ^ap_id and
	fragment("?->>'type' = ?", favorited_activity.data, "Like") and
	fragment("associated_object_id(?) = (?)->>'id'", favorited_activity.data, object.data),
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id),
	where: not exists(subquery(newer_favorite)),
	select: %Activity{activity \| pagination_id: favorited_activity.id}
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(_query, %{only_media: _val, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_media(query, %{only_media: true}) do
	from(
	[activity, object] in query,
	where: fragment("(?)->>'type' = ?", activity.data, "Create"),
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{exclude_replies: true}) do
	from(
	[activity, object] in query,
	where:
	fragment("?->>'inReplyTo' is null or ?->>'type' = 'Announce'", object.data, activity.data)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "self"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? = ANY(?)",
	object.data,
	^user.ap_id,
	activity.recipients
	)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"""
	?->>'type' != 'Create' -- This isn't a Create
	OR ?->>'inReplyTo' is null -- this isn't a reply
	OR ? && array_remove(?, ?) -- The recipient is us or one of our friends,
	-- unless they are the author (because authors
	-- are also part of the recipients). This leads
	-- to a bug that self-replies by friends won't
	-- show up.
	OR ? = ? -- The actor is us
	""",
	activity.data,
	object.data,
	^[user.ap_id \| User.get_cached_user_friends_ap_ids(user)],
	activity.recipients,
	activity.actor,
	activity.actor,
	^user.ap_id
	)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{exclude_reblogs: true}) do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, %{only_reblogs: true}) do
	from(activity in query, where: fragment("?->>'type' = 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{with_muted: true}), do: query

	defp restrict_muted(query, %{muting_user: %User{} = user} = opts) do
	mutes = opts[:muted_users_ap_ids] \|\| User.muted_users_ap_ids(user)

	query =
	from([activity] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where:
	fragment(
	"not (?->'to' \\?\| ?) or ? = ?",
	activity.data,
	^mutes,
	activity.actor,
	^user.ap_id
	)
	)

	unless opts[:skip_preload] do
	from([thread_mute: tm] in query, where: is_nil(tm.user_id))
	else
	query
	end
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{blocking_user: %User{} = user} = opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)
	domain_blocks = user.domain_blocks \|\| []

	following_ap_ids = User.get_friends_ap_ids(user)

	query =
	if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)

	from(
	[activity, object: o] in query,
	# You don't block the author
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),

	# You don't block any recipients, and didn't author the post
	where:
	fragment(
	"((not (? && ?)) or ? = ?)",
	activity.recipients,
	^blocked_ap_ids,
	activity.actor,
	^user.ap_id
	),

	# You don't block the domain of any recipients, and didn't author the post
	where:
	fragment(
	"(recipients_contain_blocked_domains(?, ?) = false) or ? = ?",
	activity.recipients,
	^domain_blocks,
	activity.actor,
	^user.ap_id
	),

	# It's not a boost of a user you block
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),

	# You don't block the author's domain, and also don't follow the author
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),

	# Same as above, but checks the Object
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_blockers_visibility(query, %{blocking_user: %User{} = user}) do
	if Config.get([:activitypub, :blockers_visible]) == true do
	query
	else
	blocker_ap_ids = User.incoming_relationships_ungrouped_ap_ids(user, [:block])

	from(
	activity in query,
	# The author doesn't block you
	where: fragment("not (? = ANY(?))", activity.actor, ^blocker_ap_ids),

	# It's not a boost of a user that blocks you
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocker_ap_ids
	)
	)
	end
	end

	defp restrict_blockers_visibility(query, _), do: query

	defp restrict_unlisted(query, %{restrict_unlisted: true}) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	defp restrict_unlisted(query, _), do: query

	defp restrict_pinned(query, %{pinned: true, pinned_object_ids: ids}) do
	from(
	[activity, object: o] in query,
	where:
	fragment(
	"(?)->>'type' = 'Create' and associated_object_id((?)) = any (?)",
	activity.data,
	activity.data,
	^ids
	)
	)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{muting_user: %User{} = user} = opts) do
	muted_reblogs = opts[:reblog_muted_users_ap_ids] \|\| User.reblog_muted_users_ap_ids(user)

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{instance: instance}) when is_binary(instance) do
	from(
	activity in query,
	where: fragment("split_part(actor::text, '/'::text, 3) = ?", ^instance)
	)
	end

	defp restrict_instance(query, _), do: query

	defp restrict_filtered(query, %{user: %User{} = user}) do
	case Filter.compose_regex(user) do
	nil ->
	query

	regex ->
	from([activity, object] in query,
	where:
	fragment("not(?->>'content' ~* ?)", object.data, ^regex) or
	activity.actor == ^user.ap_id
	)
	end
	end

	defp restrict_filtered(query, %{blocking_user: %User{} = user}) do
	restrict_filtered(query, %{user: user})
	end

	defp restrict_filtered(query, _), do: query

	defp restrict_unauthenticated(query, nil) do
	local = Config.restrict_unauthenticated_access?(:activities, :local)
	remote = Config.restrict_unauthenticated_access?(:activities, :remote)

	cond do
	local and remote ->
	from(activity in query, where: false)

	local ->
	from(activity in query, where: activity.local == false)

	remote ->
	from(activity in query, where: activity.local == true)

	true ->
	query
	end
	end

	defp restrict_unauthenticated(query, _), do: query

	defp restrict_activity_and_object_origin(query, local?) do
	local_object_prefix = Pleroma.Web.Endpoint.url() <> "/"

	# Keeping the correlated origin checks inside CASE prevents PostgreSQL from choosing a
	# global bitmap-and-sort plan before applying the account statuses limit.
	from([activity, object: object] in query,
	where:
	fragment(
	"CASE WHEN ? = ? AND starts_with((?->>'id'), ?) = ? THEN true ELSE false END",
	activity.local,
	^local?,
	object.data,
	^local_object_prefix,
	^local?
	)
	)
	end

	defp maybe_restrict_unauthenticated(
	query,
	%{restrict_unauthenticated: true, user: nil, actor_local: actor_local}
	)
	when is_boolean(actor_local) do
	local_restricted = Config.restrict_unauthenticated_access?(:activities, :local)
	remote_restricted = Config.restrict_unauthenticated_access?(:activities, :remote)
	actor_restricted = if actor_local, do: local_restricted, else: remote_restricted

	cond do
	actor_restricted ->
	from(activity in query, where: false)

	local_restricted ->
	restrict_activity_and_object_origin(query, false)

	remote_restricted ->
	restrict_activity_and_object_origin(query, true)

	true ->
	query
	end
	end

	defp maybe_restrict_unauthenticated(query, _), do: query

	defp restrict_quote_url(query, %{quote_url: quote_url}) do
	from([_activity, object] in query,
	where: fragment("(?)->'quoteUrl' = ?", object.data, ^quote_url)
	)
	end

	defp restrict_quote_url(query, _), do: query

	defp restrict_rule(query, %{rule_id: rule_id}) do
	from(
	activity in query,
	where: fragment("(?)->'rules' \\? (?)", activity.data, ^rule_id)
	)
	end

	defp restrict_rule(query, _), do: query

	defp exclude_poll_votes(query, %{include_poll_votes: true}), do: query

	defp exclude_poll_votes(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "Answer")
	)
	else
	query
	end
	end

	defp exclude_chat_messages(query, %{include_chat_messages: true}), do: query

	defp exclude_chat_messages(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
	)
	else
	query
	end
	end

	defp exclude_invisible_actors(query, %{type: "Flag"}), do: query
	defp exclude_invisible_actors(query, %{invisible_actors: true}), do: query

	defp exclude_invisible_actors(query, _opts) do
	query
	\|> join(:inner, [activity], u in User,
	as: :u,
	on: activity.actor == u.ap_id and u.invisible == false
	)
	end

	defp exclude_id(query, %{exclude_id: id}) when is_binary(id) do
	from(activity in query, where: activity.id != ^id)
	end

	defp exclude_id(query, _), do: query

	defp maybe_preload_objects(query, %{skip_preload: true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	defp maybe_preload_bookmarks(query, %{skip_preload: true}), do: query

	defp maybe_preload_bookmarks(query, opts) do
	query
	\|> Activity.with_preloaded_bookmark(opts[:user])
	end

	defp maybe_preload_report_notes(query, %{preload_report_notes: true}) do
	query
	\|> Activity.with_preloaded_report_notes()
	end

	defp maybe_preload_report_notes(query, _), do: query

	defp maybe_set_thread_muted_field(query, %{skip_preload: true}), do: query

	defp maybe_set_thread_muted_field(query, opts) do
	query
	\|> Activity.with_set_thread_muted_field(opts[:muting_user] \|\| opts[:user])
	end

	defp maybe_order(query, %{order: :desc}) do
	query
	\|> order_by(desc: :id)
	end

	defp maybe_order(query, %{order: :asc}) do
	query
	\|> order_by(asc: :id)
	end

	defp maybe_order(query, _), do: query

	defp normalize_fetch_activities_query_opts(opts) do
	Enum.reduce([:tag, :tag_all, :tag_reject], opts, fn key, opts ->
	case opts[key] do
	value when is_bitstring(value) ->
	Map.put(opts, key, Hashtag.normalize_name(value))

	value when is_list(value) ->
	normalized_value =
	value
	\|> Enum.map(&Hashtag.normalize_name/1)
	\|> Enum.uniq()

	Map.put(opts, key, normalized_value)

	_ ->
	opts
	end
	end)
	end

	defp fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts[:muting_user]
	ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relationships =
	if opts[:blocking_user] && opts[:blocking_user] == source_user do
	[:block \| ap_id_relationships]
	else
	ap_id_relationships
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

	restrict_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)
	restrict_muted_opts = Map.merge(%{muted_users_ap_ids: preloaded_ap_ids[:mute]}, opts)

	restrict_muted_reblogs_opts =
	Map.merge(%{reblog_muted_users_ap_ids: preloaded_ap_ids[:reblog_mute]}, opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	opts = normalize_fetch_activities_query_opts(opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

	query =
	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> maybe_restrict_unauthenticated(opts)
	\|> restrict_recipients_or_hashtags(recipients, opts[:user], opts[:followed_hashtags])
	\|> restrict_replies(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_remote(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_report_target(opts)
	\|> restrict_assigned_account(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_blockers_visibility(opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_filtered(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> restrict_announce_object_actor(opts)
	\|> restrict_filtered(opts)
	\|> restrict_rule(opts)
	\|> restrict_quote_url(opts)
	\|> maybe_restrict_deactivated_users(opts)
	\|> exclude_poll_votes(opts)
	\|> exclude_chat_messages(opts)
	\|> exclude_invisible_actors(opts)
	\|> exclude_visibility(opts)

	if Config.feature_enabled?(:improved_hashtag_timeline) do
	query
	\|> restrict_hashtag_any(opts)
	\|> restrict_hashtag_all(opts)
	\|> restrict_hashtag_reject_any(opts)
	else
	query
	\|> restrict_embedded_tag_any(opts)
	\|> restrict_embedded_tag_all(opts)
	\|> restrict_embedded_tag_reject_any(opts)
	end
	end

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
	def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> Activity.with_joined_object()
	\|> Object.with_joined_activity()
	\|> select([like, object, activity], %{activity \| object: object, pagination_id: like.id})
	\|> order_by([like, _, _], desc_nulls_last: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{skip_order: true}),
	pagination
	)
	end

	defp maybe_update_cc(activities, [_ \| _] = list_memberships, %User{ap_id: user_ap_id}) do
	Enum.map(activities, fn
	%{data: %{"bcc" => [_ \| _] = bcc}} = activity ->
	if Enum.any?(bcc, &(&1 in list_memberships)) do
	update_in(activity.data["cc"], &[user_ap_id \| &1])
	else
	activity
	end

	activity ->
	activity
	end)
	end

	defp maybe_update_cc(activities, _, _), do: activities

	defp fetch_activities_bounded_query(query, recipients, recipients_with_public) do
	from(activity in query,
	where:
	fragment("? && ?", activity.recipients, ^recipients) or
	(fragment("? && ?", activity.recipients, ^recipients_with_public) and
	^Constants.as_public() in activity.recipients)
	)
	end

	def fetch_activities_bounded(
	recipients,
	recipients_with_public,
	opts \\ %{},
	pagination \\ :keyset
	) do
	fetch_activities_query([], opts)
	\|> fetch_activities_bounded_query(recipients, recipients_with_public)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	end

	@spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} \| {:error, any()}
	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(sanitize_upload_file(file), opts) do
	obj_data = Maps.put_if_present(data, "actor", opts[:actor])

	Repo.insert(%Object{data: obj_data})
	end
	end

	defp sanitize_upload_file(%Plug.Upload{filename: filename} = upload) when is_binary(filename) do
	%Plug.Upload{
	upload
	\| filename: Path.basename(filename)
	}
	end

	defp sanitize_upload_file(upload), do: upload

	@spec get_actor_url(any()) :: binary() \| nil
	defp get_actor_url(url) when is_binary(url), do: url
	defp get_actor_url(%{"href" => href}) when is_binary(href), do: href

	defp get_actor_url(url) when is_list(url) do
	url
	\|> List.first()
	\|> get_actor_url()
	end

	defp get_actor_url(_url), do: nil

	defp normalize_image(%{"url" => url} = data) when is_binary(url) do
	%{
	"type" => "Image",
	"url" => [%{"href" => url}]
	}
	\|> maybe_put_description(data)
	end

	defp normalize_image(%{"url" => urls}) when is_list(urls) do
	url = urls \|> List.first()

	%{"url" => url}
	\|> normalize_image()
	end

	defp normalize_image(urls) when is_list(urls), do: urls \|> List.first() \|> normalize_image()
	defp normalize_image(_), do: nil

	defp normalize_also_known_as(urls) when is_list(urls), do: urls
	defp normalize_also_known_as(url) when is_binary(url), do: [url]
	defp normalize_also_known_as(nil), do: []

	defp maybe_put_description(map, %{"name" => description}) when is_binary(description) do
	Map.put(map, "name", description)
	end

	defp maybe_put_description(map, _), do: map

	defp object_to_user_data(data, additional) do
	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	emojis =
	data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn
	%{"type" => "Emoji"} -> true
	_ -> false
	end)
	\|> Map.new(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	is_locked = data["manuallyApprovesFollowers"] \|\| false
	capabilities = data["capabilities"] \|\| %{}
	accepts_chat_messages = capabilities["acceptsChatMessages"]
	data = Transmogrifier.maybe_fix_user_object(data)
	is_discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	featured_address = data["featured"]
	{:ok, pinned_objects} = fetch_and_prepare_featured_from_ap_id(featured_address)

	public_key =
	if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
	data["publicKey"]["publicKeyPem"]
	end

	shared_inbox =
	if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
	data["endpoints"]["sharedInbox"]
	end

	birthday =
	if is_binary(data["vcard:bday"]) do
	case Date.from_iso8601(data["vcard:bday"]) do
	{:ok, date} -> date
	{:error, _} -> nil
	end
	end

	show_birthday = !!birthday

	with {:ok, nickname} <- nickname_from_actor(data, additional) do
	{:ok,
	%{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	banner: normalize_image(data["image"]),
	fields: fields,
	emoji: emojis,
	is_locked: is_locked,
	is_discoverable: is_discoverable,
	invisible: invisible,
	avatar: normalize_image(data["icon"]),
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	featured_address: featured_address,
	bio: data["summary"] \|\| "",
	actor_type: actor_type,
	also_known_as: normalize_also_known_as(data["alsoKnownAs"]),
	public_key: public_key,
	inbox: data["inbox"],
	shared_inbox: shared_inbox,
	accepts_chat_messages: accepts_chat_messages,
	birthday: birthday,
	show_birthday: show_birthday,
	pinned_objects: pinned_objects,
	nickname: nickname
	}}
	end
	end

	defp nickname_from_actor(data, additional) do
	generated = generated_nickname(data)

	case additional[:nickname_from_acct] do
	^generated when is_binary(generated) ->
	{:ok, generated}

	acct when is_binary(acct) ->
	with ^acct <- webfinger_nickname(data) do
	{:ok, acct}
	else
	_ -> {:error, {:webfinger_actor_mismatch, acct, data["id"]}}
	end

	_ ->
	{:ok, generate_nickname(data)}
	end
	end

	defp generated_nickname(%{"preferredUsername" => username, "id" => ap_id})
	when is_binary(username) and is_binary(ap_id) do
	case URI.parse(ap_id) do
	%URI{host: host} when is_binary(host) -> "#{username}@#{host}"
	_ -> nil
	end
	end

	defp generated_nickname(_), do: nil

	defp webfinger_nickname(data) do
	with generated when is_binary(generated) <- generated_nickname(data),
	{:ok, %{"subject" => "acct:" <> acct, "ap_id" => ap_id}} <- WebFinger.finger(generated),
	true <- ap_id == data["id"] do
	acct
	end
	end

	defp generate_nickname(%{"preferredUsername" => username} = data) when is_binary(username) do
	generated = generated_nickname(data)

	if Config.get([WebFinger, :update_nickname_on_user_fetch]) do
	case webfinger_nickname(data) do
	acct when is_binary(acct) -> acct
	_ -> generated
	end
	else
	generated
	end
	end

	# nickname can be nil because of virtual actors
	defp generate_nickname(_), do: nil

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	end
	end

	defp normalize_counter(counter) when is_integer(counter), do: counter
	defp normalize_counter(_), do: 0

	def maybe_update_follow_information(user_data) do
	with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
	{_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
	{_, true} <-
	{:collections_available,
	!!(user_data[:following_address] && user_data[:follower_address])},
	{:ok, info} <-
	fetch_follow_information_for_user(user_data) do
	info = Map.merge(user_data[:info] \|\| %{}, info)

	user_data
	\|> Map.put(:info, info)
	else
	{:user_type_check, false} ->
	user_data

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

	e ->
	Logger.error(
	"Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
	)

	user_data
	end
	end

	defp collection_private(%{"first" => %{"type" => type}})
	when type in ["CollectionPage", "OrderedCollectionPage"],
	do: {:ok, false}

	defp collection_private(%{"first" => first}) do
	with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
	Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, false}
	else
	{:error, _} -> {:ok, true}
	end
	end

	defp collection_private(_data), do: {:ok, true}

	def user_data_from_user_object(data, additional \\ []) do
	with {:ok, data} <- MRF.filter(data),
	{:ok, data} <- object_to_user_data(data, additional) do
	{:ok, data}
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data, additional) do
	{:ok, maybe_update_follow_information(data)}
	else
	# If this has been deleted, only log a debug and not an error
	{:error, "Object has been deleted" = e} ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	{:error, {:reject, reason} = e} ->
	Logger.info("Rejected user #{ap_id}: #{inspect(reason)}")
	{:error, e}

	{:error, e} ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

	def maybe_handle_clashing_nickname(data) do
	with nickname when is_binary(nickname) <- data[:nickname],
	%User{} = old_user <- User.get_by_nickname(nickname),
	{_, false} <- {:ap_id_comparison, data[:ap_id] == old_user.ap_id} do
	Logger.info(
	"Found an old user for #{nickname}, the old ap id is #{old_user.ap_id}, new one is #{data[:ap_id]}, renaming."
	)

	old_user
	\|> User.remote_user_changeset(%{nickname: "#{old_user.id}.#{old_user.nickname}"})
	\|> User.update_and_set_cache()
	else
	{:ap_id_comparison, true} ->
	Logger.info(
	"Found an old user for #{data[:nickname]}, but the ap id #{data[:ap_id]} is the same as the new user. Race condition? Not changing anything."
	)

	_ ->
	nil
	end
	end

	@featured_collection_types ["OrderedCollection", "Collection"]
	@featured_collection_page_types ["OrderedCollectionPage", "CollectionPage"]
	@featured_collection_item_types @featured_collection_types ++ @featured_collection_page_types

	def pin_data_from_featured_collection(%{
	"type" => type,
	"orderedItems" => objects
	})
	when type in @featured_collection_item_types do
	Map.new(objects, fn
	%{"id" => object_ap_id} -> {object_ap_id, NaiveDateTime.utc_now()}
	object_ap_id when is_binary(object_ap_id) -> {object_ap_id, NaiveDateTime.utc_now()}
	end)
	end

	def pin_data_from_featured_collection(obj) do
	Logger.error("Could not parse featured collection #{inspect(obj)}")
	%{}
	end

	def fetch_and_prepare_featured_from_ap_id(nil) do
	{:ok, %{}}
	end

	def fetch_and_prepare_featured_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
	{:ok, prepare_featured_collection(data)}
	else
	e ->
	Logger.error("Could not decode featured collection at fetch #{ap_id}, #{inspect(e)}")
	{:ok, %{}}
	end
	end

	defp prepare_featured_collection(%{"orderedItems" => objects} = data) when is_list(objects) do
	pin_data_from_featured_collection(data)
	end

	defp prepare_featured_collection(%{
	"type" => type,
	"first" => %{"type" => page_type} = first
	})
	when type in @featured_collection_types and page_type in @featured_collection_page_types do
	pin_data_from_featured_collection(first)
	end

	defp prepare_featured_collection(%{"type" => type, "first" => first})
	when type in @featured_collection_types and is_binary(first) do
	case Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, data} ->
	pin_data_from_featured_collection(data)

	e ->
	Logger.error("Could not decode featured collection page at fetch #{first}, #{inspect(e)}")
	%{}
	end
	end

	defp prepare_featured_collection(data) do
	pin_data_from_featured_collection(data)
	end

	def enqueue_pin_fetches(%{pinned_objects: pins}) do
	# enqueue a task to fetch all pinned objects
	Enum.each(pins, fn {ap_id, _} ->
	if is_nil(Object.get_cached_by_ap_id(ap_id)) do
	Pleroma.Workers.RemoteFetcherWorker.new(%{
	"op" => "fetch_remote",
	"id" => ap_id,
	"depth" => 1
	})
	\|> Oban.insert()
	end
	end)
	end

	def enqueue_pin_fetches(_), do: nil

	def make_user_from_ap_id(ap_id, additional \\ []) do
	user = User.get_cached_by_ap_id(ap_id)

	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	enqueue_pin_fetches(data)

	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	maybe_handle_clashing_nickname(data)

	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id, "subject" => "acct:" <> acct}} when not is_nil(ap_id) <-
	WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id, nickname_from_acct: acct)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	# filter out broken threads
	defp contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{type: "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end

	defp maybe_restrict_deactivated_users(activity, %{type: "Flag"}), do: activity

	defp maybe_restrict_deactivated_users(activity, _opts),
	do: Activity.restrict_deactivated_users(activity)
	end
	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 3b208ab77..da4450347 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,423 +1,430 @@
	# 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.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

	This module encodes our addressing policies and general shape of our objects.
	"""

	alias Pleroma.Activity
	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft

	require Pleroma.Constants

	def accept_or_reject(actor, activity, type) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => type,
	"object" => activity.data["id"],
	"to" => [activity.actor]
	}

	{:ok, data, []}
	end

	@spec reject(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def reject(actor, rejected_activity) do
	accept_or_reject(actor, rejected_activity, "Reject")
	end

	@spec accept(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def accept(actor, accepted_activity) do
	accept_or_reject(actor, accepted_activity, "Accept")
	end

	@spec follow(User.t(), User.t()) :: {:ok, map(), keyword()}
	def follow(follower, followed) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	}

	{:ok, data, []}
	end

	defp unicode_emoji_react(_object, data, emoji) do
	data
	\|> Map.put("content", emoji)
	\|> Map.put("type", "EmojiReact")
	end

	defp add_emoji_content(data, emoji, url) do
	tag = [
	Emoji.build_emoji_tag({Emoji.maybe_strip_name(emoji), url})
	]

	data
	\|> Map.put("content", Emoji.maybe_quote(emoji))
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("tag", tag)
	end

	defp remote_custom_emoji_react(
	%{data: %{"reactions" => existing_reactions}},
	data,
	emoji
	) do
	[emoji_code, instance] = String.split(Emoji.maybe_strip_name(emoji), "@")

	matching_reaction =
	Enum.find(
	existing_reactions,
	fn [name, _, url] ->
	if url != nil do
	url = URI.parse(url)
	url.host == instance && name == emoji_code
	end
	end
	)

	if matching_reaction do
	[name, _, url] = matching_reaction
	add_emoji_content(data, name, url)
	else
	{:error, "Could not react"}
	end
	end

	defp remote_custom_emoji_react(_object, _data, _emoji) do
	{:error, "Could not react"}
	end

	defp local_custom_emoji_react(data, emoji) do
	with %{file: path} = emojo <- Emoji.get(emoji) do
	url = Emoji.local_url(path)
	add_emoji_content(data, emojo.code, url)
	else
	_ -> {:error, "Emoji does not exist"}
	end
	end

	defp custom_emoji_react(object, data, emoji) do
	if String.contains?(emoji, "@") do
	remote_custom_emoji_react(object, data, emoji)
	else
	local_custom_emoji_react(data, emoji)
	end
	end

	@spec emoji_react(User.t(), Object.t(), String.t()) :: {:ok, map(), keyword()}
	def emoji_react(actor, object, emoji) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	if Emoji.unicode?(emoji) do
	unicode_emoji_react(object, data, emoji)
	else
	custom_emoji_react(object, data, emoji)
	end

	{:ok, data, meta}
	end
	end

	@spec undo(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def undo(actor, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Undo",
	"object" => object.data["id"],
	"to" => object.data["to"] \|\| [],
	"cc" => object.data["cc"] \|\| []
	}, []}
	end

	@spec delete(User.t(), String.t()) :: {:ok, map(), keyword()}
	def delete(actor, object_id) do
	object = Object.normalize(object_id, fetch: false)

	user = !object && User.get_cached_by_ap_id(object_id)

	to =
	case {object, user} do
	{%Object{}, _} ->
	# We are deleting an object, address everyone who was originally mentioned
	(object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	{_, %User{follower_address: follower_address}} ->
	# We are deleting a user, address the followers of that user
	[follower_address]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object_id,
	"to" => to,
	"type" => "Delete"
	}, []}
	end

	def create(actor, object, recipients) do
	context =
	if is_map(object) do
	object["context"]
	else
	nil
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	"object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Pleroma.Maps.put_if_present("context", context), []}
	end

	@spec note(ActivityDraft.t()) :: {:ok, map(), keyword()}
	def note(%ActivityDraft{} = draft) do
	data =
	%{
	+ "id" => Utils.generate_object_id(),
	"type" => "Note",
	+ "published" => Utils.make_date(),
	"to" => draft.to,
	"cc" => draft.cc,
	"content" => draft.content_html,
	"summary" => draft.summary,
	"sensitive" => draft.sensitive,
	"context" => draft.context,
	"attachment" => draft.attachments,
	"actor" => draft.user.ap_id,
	- "tag" => Keyword.values(draft.tags) \|> Enum.uniq()
	+ "tag" =>
	+ draft.tags
	+ \|> Keyword.values()
	+ \|> Enum.uniq()
	+ \|> Enum.map(&Transmogrifier.build_hashtag_tag/1)
	}
	\|> add_in_reply_to(draft.in_reply_to)
	\|> add_quote(draft.quote_post)
	\|> Map.merge(draft.extra)

	{:ok, data, []}
	end

	defp add_in_reply_to(object, nil), do: object

	defp add_in_reply_to(object, in_reply_to) do
	with %Object{} = in_reply_to_object <- Object.normalize(in_reply_to, fetch: false) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end
	end

	defp add_quote(object, nil), do: object

	defp add_quote(object, quote_post) do
	with %Object{} = quote_object <- Object.normalize(quote_post, fetch: false) do
	Map.put(object, "quoteUrl", quote_object.data["id"])
	else
	_ -> object
	end
	end

	def chat_message(actor, recipient, content, opts \\ []) do
	basic = %{
	"id" => Utils.generate_object_id(),
	"actor" => actor.ap_id,
	"type" => "ChatMessage",
	"to" => [recipient],
	"content" => content,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"emoji" => Emoji.Formatter.get_emoji_map(content)
	}

	case opts[:attachment] do
	%Object{data: attachment_data} ->
	{
	:ok,
	Map.put(basic, "attachment", attachment_data),
	[]
	}

	_ ->
	{:ok, basic, []}
	end
	end

	def answer(user, object, name) do
	{:ok,
	%{
	"type" => "Answer",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"],
	"context" => object.data["context"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"id" => Utils.generate_object_id()
	}, []}
	end

	@spec tombstone(String.t(), String.t()) :: {:ok, map(), keyword()}
	def tombstone(actor, id) do
	{:ok,
	%{
	"id" => id,
	"actor" => actor,
	"type" => "Tombstone"
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("type", "Like")

	{:ok, data, meta}
	end
	end

	@spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def update(actor, object) do
	{to, cc} =
	if object["type"] in Pleroma.Constants.actor_types() do
	# User updates, always public
	{[Pleroma.Constants.as_public(), actor.follower_address], []}
	else
	# Status updates, follow the recipients in the object
	{object["to"] \|\| [], object["cc"] \|\| []}
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Update",
	"actor" => actor.ap_id,
	"object" => object,
	"to" => to,
	"cc" => cc
	}, []}
	end

	@spec block(User.t(), User.t(), map()) :: {:ok, map(), keyword()}
	def block(blocker, blocked, params \\ %{}) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Block",
	"actor" => blocker.ap_id,
	"object" => blocked.ap_id,
	"to" => [blocked.ap_id]
	}, Keyword.new(params)}
	end

	@spec announce(User.t(), Object.t(), keyword()) :: {:ok, map(), keyword()}
	def announce(actor, object, options \\ []) do
	visibility = Keyword.get(options, :visibility, "public")

	{to, cc} =
	if actor.ap_id == Relay.ap_id() do
	{[actor.follower_address], []}
	else
	Pleroma.Web.CommonAPI.Utils.get_to_and_cc_for_visibility(
	visibility,
	actor.follower_address,
	nil,
	[object.data["actor"]]
	)
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"],
	"type" => "Announce",
	"published" => Utils.make_date()
	}, []}
	end

	@spec object_action(User.t(), Object.t()) :: {:ok, map(), keyword()}
	defp object_action(actor, object) do
	object_actor = User.get_cached_by_ap_id(object.data["actor"])

	# Address the actor of the object, and our actor's follower collection if the post is public.
	to =
	if Visibility.public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	# CC everyone who's been addressed in the object, except ourself and the object actor's
	# follower collection
	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end

	@spec pin(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def pin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	@spec unpin(User.t(), Object.t()) :: {:ok, map, keyword()}
	def unpin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	defp pinned_url(nickname) when is_binary(nickname) do
	Pleroma.Web.Router.Helpers.activity_pub_url(Pleroma.Web.Endpoint, :pinned, nickname)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/common_fields.ex b/lib/pleroma/web/activity_pub/object_validators/common_fields.ex
	index 9b8580200..6d2ce24f7 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/common_fields.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/common_fields.ex
	@@ -1,72 +1,78 @@
	# 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.CommonFields do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator

	# Activities and Objects, except (Create)ChatMessage
	defmacro message_fields do
	quote bind_quoted: binding() do
	field(:type, :string)
	field(:id, ObjectValidators.ObjectID, primary_key: true)

	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	end
	end

	defmacro activity_fields do
	quote bind_quoted: binding() do
	field(:object, ObjectValidators.ObjectID)
	field(:actor, ObjectValidators.ObjectID)
	end
	end

	# All objects except Answer and ChatMessage
	defmacro object_fields do
	quote bind_quoted: binding() do
	field(:content, :string)
	field(:contentMap, ObjectValidators.ContentLanguageMap)
	field(:htmlMfm, :boolean)

	field(:published, ObjectValidators.DateTime)
	field(:updated, ObjectValidators.DateTime)
	field(:emoji, ObjectValidators.Emoji, default: %{})
	embeds_many(:attachment, AttachmentValidator)
	end
	end

	# Basically objects that aren't ChatMessage and Answer
	defmacro status_object_fields do
	quote bind_quoted: binding() do
	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)
	field(:attributedTo, ObjectValidators.ObjectID)

	embeds_many(:tag, TagValidator)

	field(:name, :string)
	field(:summary, :string)

	field(:context, :string)

	field(:sensitive, :boolean, default: false)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:quotes_count, :integer, default: 0)
	field(:language, ObjectValidators.LanguageCode)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:quoteUrl, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.BareUri)

	field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	+
	+ field(:directMessage, :boolean)
	+
	+ # Local-only fields, stripped from incoming and outgoing objects
	+ field(:generator, :map)
	+ field(:listMessage, ObjectValidators.ObjectID)
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex b/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex
	index 2395abfd4..f94bfdea6 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex
	@@ -1,161 +1,166 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	# Code based on CreateChatMessageValidator
	# NOTES
	# - doesn't embed, will only get the object id
	defmodule Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false

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

	+ field(:published, ObjectValidators.DateTime)
	field(:expires_at, ObjectValidators.DateTime)

	# Should be moved to object, done for CommonAPI.Utils.make_context
	field(:context, :string)
	+
	+ # Local-only fields set by CommonAPI
	+ field(:directMessage, :boolean)
	+ field(:listMessage, ObjectValidators.ObjectID)
	end

	def cast_data(data, meta \\ []) do
	data = fix(data, meta)

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

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

	def cast_and_validate(data, meta \\ []) do
	data
	\|> cast_data(meta)
	\|> validate_data(meta)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	# CommonFixes.fix_activity_addressing adapted for Create specific behavior
	defp fix_addressing(data, object) do
	%User{follower_address: follower_collection} = User.get_cached_by_ap_id(data["actor"])

	data
	\|> CommonFixes.cast_and_filter_recipients("to", follower_collection, object["to"])
	\|> CommonFixes.cast_and_filter_recipients("cc", follower_collection, object["cc"])
	\|> CommonFixes.cast_and_filter_recipients("bto", follower_collection, object["bto"])
	\|> CommonFixes.cast_and_filter_recipients("bcc", follower_collection, object["bcc"])
	\|> Transmogrifier.fix_implicit_addressing(follower_collection)
	end

	def fix(data, meta) do
	object = meta[:object_data]

	data
	\|> CommonFixes.fix_actor()
	\|> Map.put("context", object["context"])
	\|> fix_addressing(object)
	end

	defp validate_data(cng, meta) do
	object = meta[:object_data]

	cng
	\|> validate_required([:actor, :type, :object, :to, :cc])
	\|> validate_inclusion(:type, ["Create"])
	\|> CommonValidations.validate_actor_presence()
	\|> validate_actors_match(object)
	\|> validate_context_match(object)
	\|> validate_addressing_match(object)
	\|> validate_object_nonexistence()
	\|> validate_object_containment()
	end

	def validate_object_containment(cng) do
	actor = get_field(cng, :actor)

	cng
	\|> validate_change(:object, fn :object, object_id ->
	%URI{host: object_id_host} = URI.parse(object_id)
	%URI{host: actor_host} = URI.parse(actor)

	if object_id_host == actor_host do
	[]
	else
	[{:object, "The host of the object id doesn't match with the host of the actor"}]
	end
	end)
	end

	def validate_object_nonexistence(cng) do
	cng
	\|> validate_change(:object, fn :object, object_id ->
	if Object.get_cached_by_ap_id(object_id) do
	[{:object, "The object to create already exists"}]
	else
	[]
	end
	end)
	end

	def validate_actors_match(cng, object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]

	cng
	\|> validate_change(:actor, fn :actor, actor ->
	if actor == attributed_to do
	[]
	else
	[{:actor, "Actor doesn't match with object attributedTo"}]
	end
	end)
	end

	def validate_context_match(cng, %{"context" => object_context}) do
	cng
	\|> validate_change(:context, fn :context, context ->
	if context == object_context do
	[]
	else
	[{:context, "context field not matching between Create and object (#{object_context})"}]
	end
	end)
	end

	def validate_addressing_match(cng, object) do
	[:to, :cc, :bcc, :bto]
	\|> Enum.reduce(cng, fn field, cng ->
	object_data = object[to_string(field)]

	validate_change(cng, field, fn field, data ->
	if data == object_data do
	[]
	else
	[{field, "field doesn't match with object (#{inspect(object_data)})"}]
	end
	end)
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index c41216b87..f4a53f07a 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,694 +1,698 @@
	# 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.SideEffects do
	@moduledoc """
	This module looks at an inserted object and executes the side effects that it
	implies. For example, a `Like` activity will increase the like count on the
	liked object, a `Follow` activity will add the user to the follower
	collection, and so on.
	"""
	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	+ alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Streamer
	alias Pleroma.Workers.PollWorker

	require Pleroma.Constants
	require Logger

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	@logger Pleroma.Config.get([:side_effects, :logger], Logger)

	@behaviour Pleroma.Web.ActivityPub.SideEffects.Handling

	defp ap_streamer, do: Pleroma.Config.get([:side_effects, :ap_streamer], ActivityPub)

	@impl true
	def handle(object, meta \\ [])

	# Task this handles
	# - Follows
	# - Sends a notification
	@impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Accept",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _follower, followed} <-
	FollowingRelationship.update(follower, followed, :follow_accept) do
	Notification.update_notification_type(followed, follow_activity)
	end

	{:ok, object, meta}
	end

	# Task this handles
	# - Rejects all existing follow activities for this person
	# - Updates the follow state
	# - Dismisses notification
	@impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Reject",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, _follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject") do
	FollowingRelationship.update(follower, followed, :follow_reject)
	Notification.dismiss(follow_activity)
	end

	{:ok, object, meta}
	end

	# Tasks this handle
	# - Follows if possible
	# - Sends a notification
	# - Generates accept or reject if appropriate
	@impl true
	def handle(
	%{
	data: %{
	"id" => follow_id,
	"type" => "Follow",
	"object" => followed_user,
	"actor" => following_user
	}
	} = object,
	meta
	) do
	with %User{} = follower <- User.get_cached_by_ap_id(following_user),
	%User{} = followed <- User.get_cached_by_ap_id(followed_user),
	{_, {:ok, _, _}, _, _} <-
	{:following, User.follow(follower, followed, :follow_pending), follower, followed} do
	if followed.local && !followed.is_locked do
	{:ok, accept_data, _} = Builder.accept(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(accept_data, local: true)
	end
	else
	{:following, {:error, _}, _follower, followed} ->
	{:ok, reject_data, _} = Builder.reject(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(reject_data, local: true)

	_ ->
	nil
	end

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)

	updated_object = Activity.get_by_ap_id(follow_id)

	{:ok, updated_object, meta}
	end

	# Tasks this handles:
	# - Unfollow and block
	@impl true
	def handle(
	%{data: %{"type" => "Block", "object" => blocked_user, "actor" => blocking_user}} =
	object,
	meta
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocking_user),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked_user) do
	User.block(blocker, blocked, Enum.into(meta, %{}))
	end

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Update the user
	# - Update a non-user object (Note, Question, etc.)
	#
	# For a local user, we also get a changeset with the full information, so we
	# can update non-federating, non-activitypub settings as well.
	@impl true
	def handle(%{data: %{"type" => "Update", "object" => updated_object}} = object, meta) do
	updated_object_id = updated_object["id"]

	with {_, true} <- {:has_id, is_binary(updated_object_id)},
	%{"type" => type} <- updated_object,
	{_, is_user} <- {:is_user, type in Pleroma.Constants.actor_types()} do
	if is_user do
	handle_update_user(object, meta)
	else
	handle_update_object(object, meta)
	end
	else
	_ ->
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	@impl true
	def handle(%{data: %{"type" => "Like"}} = object, meta) do
	liked_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_like_to_object(object, liked_object)

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Increase the user note count
	# - Increase the reply count
	# - Increase replies count
	# - Set up ActivityExpiration
	# - Set up notifications
	# - Index incoming posts for search (if needed)
	@impl true
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, object, meta} <- handle_object_creation(meta[:object_data], activity, meta),
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	+ activity = Map.put(activity, :object, object)
	{:ok, notifications} = Notification.create_notifications(activity)
	{:ok, _user} = ActivityPub.increase_note_count_if_public(user, object)
	{:ok, _user} = ActivityPub.update_last_status_at_if_public(user, object)

	- if in_reply_to = object.data["type"] != "Answer" && object.data["inReplyTo"] do
	- Object.increase_replies_count(in_reply_to)
	- end
	+ if Visibility.public?(object) do
	+ if in_reply_to = object.data["type"] != "Answer" && object.data["inReplyTo"] do
	+ Object.increase_replies_count(in_reply_to)
	+ end

	- if quote_url = object.data["quoteUrl"] do
	- Object.increase_quotes_count(quote_url)
	+ if quote_url = object.data["quoteUrl"] do
	+ Object.increase_quotes_count(quote_url)
	+ end
	end

	reply_depth = (meta[:depth] \|\| 0) + 1

	# FIXME: Force inReplyTo to replies
	- if Pleroma.Web.Federator.allowed_thread_distance?(reply_depth) and
	- object.data["replies"] != nil do
	+ if object.data["replies"] not in [nil, []] and
	+ Pleroma.Web.Federator.allowed_thread_distance?(reply_depth) do
	for reply_id <- object.data["replies"] do
	Pleroma.Workers.RemoteFetcherWorker.new(%{
	"op" => "fetch_remote",
	"id" => reply_id,
	"depth" => reply_depth
	})
	\|> Oban.insert()
	end
	end

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)

	- Pleroma.Search.add_to_index(Map.put(activity, :object, object))
	+ Pleroma.Search.add_to_index(activity)

	Utils.maybe_handle_group_posts(activity)

	meta =
	meta
	\|> add_notifications(notifications)
	\|> add_stream_out(activity)
	\|> handle_conversation(activity)

	{:ok, activity, meta}
	else
	e -> Repo.rollback(e)
	end
	end

	# Tasks this handles:
	# - Add announce to object
	# - Set up notification
	# - Stream out the announce
	@impl true
	def handle(%{data: %{"type" => "Announce"}} = object, meta) do
	announced_object = Object.get_by_ap_id(object.data["object"])
	user = User.get_cached_by_ap_id(object.data["actor"])

	Utils.add_announce_to_object(object, announced_object)

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)
	\|> maybe_add_stream_out(object, !User.internal?(user))

	{:ok, object, meta}
	end

	@impl true
	def handle(%{data: %{"type" => "Undo", "object" => undone_object}} = object, meta) do
	with undone_object <- Activity.get_by_ap_id(undone_object),
	:ok <- handle_undoing(undone_object) do
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	@impl true
	def handle(%{data: %{"type" => "EmojiReact"}} = object, meta) do
	reacted_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_emoji_reaction_to_object(object, reacted_object)

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	# - Removes posts from search index (if needed)
	@impl true
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, fetch: false) \|\|
	User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	with {_, {:ok, deleted_object, _activity}} <- {:object, Object.delete(deleted_object)},
	{_, actor} when is_binary(actor) <- {:actor, deleted_object.data["actor"]},
	{_, %User{} = user} <- {:user, User.get_cached_by_ap_id(actor)} do
	User.remove_pinned_object_id(user, deleted_object.data["id"])

	{:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)

	if in_reply_to = deleted_object.data["inReplyTo"] do
	Object.decrease_replies_count(in_reply_to)
	end

	if quote_url = deleted_object.data["quoteUrl"] do
	Object.decrease_quotes_count(quote_url)
	end

	MessageReference.delete_for_object(deleted_object)

	meta =
	meta
	\|> add_stream_out(object)
	\|> add_stream_out_participations(deleted_object, user)

	{:ok, meta}
	else
	{:actor, _} ->
	@logger.error("The object doesn't have an actor: #{inspect(deleted_object)}")
	:no_object_actor

	{:user, _} ->
	@logger.error(
	"The object's actor could not be resolved to a user: #{inspect(deleted_object)}"
	)

	:no_object_user

	{:object, _} ->
	@logger.error("The object could not be deleted: #{inspect(deleted_object)}")
	{:error, object}
	end

	%User{} ->
	with {:ok, _} <- User.delete(deleted_object) do
	{:ok, meta}
	end
	end

	case result do
	{:ok, meta} ->
	# Only remove from index when deleting actual objects, not users or anything else
	with %Pleroma.Object{} <- deleted_object do
	Pleroma.Search.remove_from_index(deleted_object)
	end

	{:ok, object, meta}

	error ->
	{:error, error}
	end
	end

	# Tasks this handles:
	# - adds pin to user
	# - removes expiration job for pinned activity, if was set for expiration
	@impl true
	def handle(%{data: %{"type" => "Add"} = data} = object, meta) do
	with %User{} = user <- User.get_cached_by_ap_id(data["actor"]),
	{:ok, _user} <- User.add_pinned_object_id(user, data["object"]) do
	# if pinned activity was scheduled for deletion, we remove job
	if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(meta[:activity_id]) do
	Oban.cancel_job(expiration.id)
	end

	{:ok, object, meta}
	else
	nil ->
	{:error, :user_not_found}

	{:error, changeset} ->
	if changeset.errors[:pinned_objects] do
	{:error, :pinned_statuses_limit_reached}
	else
	changeset.errors
	end
	end
	end

	# Tasks this handles:
	# - removes pin from user
	# - removes corresponding Add activity
	# - if activity had expiration, recreates activity expiration job
	@impl true
	def handle(%{data: %{"type" => "Remove"} = data} = object, meta) do
	with %User{} = user <- User.get_cached_by_ap_id(data["actor"]),
	{:ok, _user} <- User.remove_pinned_object_id(user, data["object"]) do
	data["object"]
	\|> Activity.add_by_params_query(user.ap_id, user.featured_address)
	\|> Repo.delete_all()

	# if pinned activity was scheduled for deletion, we reschedule it for deletion
	if meta[:expires_at] do
	# MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
	{:ok, expires_at} =
	Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast(meta[:expires_at])

	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: meta[:activity_id]
	},
	scheduled_at: expires_at
	)
	end

	{:ok, object, meta}
	else
	nil -> {:error, :user_not_found}
	error -> error
	end
	end

	# Nothing to do
	@impl true
	def handle(object, meta) do
	{:ok, object, meta}
	end

	defp handle_update_user(
	%{data: %{"type" => "Update", "object" => updated_object}} = object,
	meta
	) do
	if changeset = Keyword.get(meta, :user_update_changeset) do
	changeset
	\|> User.update_and_set_cache()
	else
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(updated_object)

	User.get_by_ap_id(updated_object["id"])
	\|> User.remote_user_changeset(new_user_data)
	\|> User.update_and_set_cache()
	end

	{:ok, object, meta}
	end

	defp handle_update_object(
	%{data: %{"type" => "Update", "object" => updated_object}} = object,
	meta
	) do
	orig_object_ap_id = updated_object["id"]
	orig_object = Object.get_by_ap_id(orig_object_ap_id)
	orig_object_data = Map.get(orig_object, :data)

	updated_object =
	if meta[:local] do
	# If this is a local Update, we don't process it by transmogrifier,
	# so we use the embedded object as-is.
	updated_object
	else
	meta[:object_data]
	end

	with true <- orig_object_data["type"] in Pleroma.Constants.updatable_object_types(),
	{:ok, _, true} <-
	Object.Updater.do_update_and_invalidate_cache(orig_object, updated_object) do
	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)
	\|> add_stream_out(Activity.normalize(object))
	\|> handle_conversation(Activity.get_create_by_object_ap_id_with_object(orig_object_ap_id))

	{:ok, object, meta}
	else
	_ -> {:ok, object, meta}
	end
	end

	# Creates or bumps the conversation of a direct message, marks it as read for
	# the author and queues the participations for streaming.
	defp handle_conversation(meta, %Activity{} = activity) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = author <- User.get_cached_by_ap_id(activity.actor) do
	Participation.mark_as_read(author, conversation)

	participations =
	conversation
	\|> Repo.preload([participations: :user], force: true)
	\|> Map.get(:participations)

	add_streamables(meta, [{"participation", participations}])
	else
	_ -> meta
	end
	end

	defp handle_conversation(meta, _), do: meta

	def handle_object_creation(%{"type" => "ChatMessage"} = object, _activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	actor = User.get_cached_by_ap_id(object.data["actor"])
	recipient = User.get_cached_by_ap_id(hd(object.data["to"]))

	streamables =
	[[actor, recipient], [recipient, actor]]
	\|> Enum.uniq()
	\|> Enum.map(fn [user, other_user] ->
	if user.local do
	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	{:ok, cm_ref} = MessageReference.create(chat, object, user.ap_id != actor.ap_id)

	@cachex.put(
	:chat_message_id_idempotency_key_cache,
	cm_ref.id,
	meta[:idempotency_key]
	)

	{
	["user", "user:pleroma_chat"],
	{user, %{cm_ref \| chat: chat, object: object}}
	}
	end
	end)
	\|> Enum.filter(& &1)

	meta =
	meta
	\|> add_streamables(streamables)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Question"} = object, activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	PollWorker.schedule_poll_end(activity)
	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Answer"} = object_map, _activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object_map, meta) do
	Object.increase_vote_count(
	object.data["inReplyTo"],
	object.data["name"],
	object.data["actor"]
	)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => objtype} = object, _activity, meta)
	when objtype in ~w[Audio Video Image Event Article Note Page] do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	{:ok, object, meta}
	end
	end

	# Nothing to do
	def handle_object_creation(object, _activity, meta) do
	{:ok, object, meta}
	end

	defp undo_like(nil, object), do: delete_object(object)

	defp undo_like(%Object{} = liked_object, object) do
	with {:ok, _} <- Utils.remove_like_from_object(object, liked_object) do
	delete_object(object)
	end
	end

	def handle_undoing(%{data: %{"type" => "Like"}} = object) do
	object.data["object"]
	\|> Object.get_by_ap_id()
	\|> undo_like(object)
	end

	def handle_undoing(%{data: %{"type" => "EmojiReact"}} = object) do
	with %Object{} = reacted_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_emoji_reaction_from_object(object, reacted_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "Announce"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_announce_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(
	%{data: %{"type" => "Block", "actor" => blocker, "object" => blocked}} = object
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocker),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, _} <- User.unblock(blocker, blocked),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(object), do: {:error, ["don't know how to handle", object]}

	@spec delete_object(Activity.t()) :: :ok \| {:error, Ecto.Changeset.t()}
	defp delete_object(object) do
	with {:ok, _} <- Repo.delete(object), do: :ok
	end

	defp stream_notifications(meta) do
	Keyword.get(meta, :notifications, [])
	\|> Notification.stream()

	meta
	end

	defp send_streamables(meta) do
	Keyword.get(meta, :streamables, [])
	\|> Enum.each(fn {topics, items} ->
	Streamer.stream(topics, items)
	end)

	meta
	end

	defp stream_out_activities(meta) do
	Keyword.get(meta, :stream_out, [])
	\|> Enum.each(fn activity -> ap_streamer().stream_out(activity) end)

	meta
	end

	defp stream_out_participations(meta) do
	Keyword.get(meta, :stream_out_participations, [])
	\|> Enum.each(fn {object, user} -> ap_streamer().stream_out_participations(object, user) end)

	meta
	end

	# Streaming is deferred until after the transaction commits, so that the
	# streamer processes (which use their own database connections) can see the
	# persisted activity and its side effects.
	defp add_stream_out(meta, activity) do
	Keyword.update(meta, :stream_out, [activity], &(&1 ++ [activity]))
	end

	defp maybe_add_stream_out(meta, activity, true), do: add_stream_out(meta, activity)
	defp maybe_add_stream_out(meta, _activity, false), do: meta

	defp add_stream_out_participations(meta, object, user) do
	Keyword.update(meta, :stream_out_participations, [{object, user}], &(&1 ++ [{object, user}]))
	end

	defp add_streamables(meta, streamables) do
	existing = Keyword.get(meta, :streamables, [])

	meta
	\|> Keyword.put(:streamables, streamables ++ existing)
	end

	defp add_notifications(meta, notifications) do
	existing = Keyword.get(meta, :notifications, [])

	meta
	\|> Keyword.put(:notifications, notifications ++ existing)
	end

	@impl true
	def handle_after_transaction(meta) do
	meta
	\|> stream_out_activities()
	\|> stream_notifications()
	\|> send_streamables()
	\|> stream_out_participations()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 33ab62ca3..51694c194 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1207 +1,1216 @@
	# 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 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

	defp valid_http_url?(href) when is_binary(href) do
	match?({:ok, _}, ObjectValidators.Uri.cast(href))
	end

	defp valid_http_url?(_), do: false

	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"])

	%{
	"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

	_ ->
	nil
	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 is_binary(data["name"]) and data["icon"]
	end)
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	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)
	+ # Incoming objects have their internal "emoji" field stripped, so this only
	+ # keeps the emoji of locally built objects.
	+ existing_emoji =
	+ (object["emoji"] \|\| %{})
	+ \|> Enum.filter(fn {name, url} -> is_binary(name) and valid_http_url?(url) end)
	+ \|> Map.new()
	+
	+ Map.put(object, "emoji", Map.merge(existing_emoji, emoji))
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji", "name" => name} = tag} = object)
	when is_binary(name) do
	name = String.trim(name, ":")

	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 ->
	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"
	- }
	-
	+ tag when is_binary(tag) -> build_hashtag_tag(tag)
	# Do not process tags which are already AS2 tag objects.
	- tag when is_map(tag) ->
	- tag
	+ tag when is_map(tag) -> tag
	end)
	+ \|> Enum.uniq()

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

	+ def build_hashtag_tag(name) when is_binary(name) do
	+ %{
	+ "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{name}",
	+ "name" => "##{name}",
	+ "type" => "Hashtag"
	+ }
	+ 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/lib/pleroma/web/common_api.ex b/lib/pleroma/web/common_api.ex
	index 220a8a228..07d301fae 100644
	--- a/lib/pleroma/web/common_api.ex
	+++ b/lib/pleroma/web/common_api.ex
	@@ -1,797 +1,827 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Formatter
	alias Pleroma.ModerationLog
	alias Pleroma.Object
	alias Pleroma.Rule
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft

	import Ecto.Query, only: [where: 3]
	import Pleroma.Web.Gettext
	import Pleroma.Web.CommonAPI.Utils

	require Pleroma.Constants
	require Logger

	@spec block(User.t(), User.t()) :: {:ok, Activity.t()} \| Pipeline.errors()
	def block(blocked, blocker, params \\ %{}) do
	with {:ok, block_data, meta} <- Builder.block(blocker, blocked, params),
	{:ok, block, _} <- Pipeline.common_pipeline(block_data, meta ++ [local: true]) do
	{:ok, block}
	end
	end

	@spec post_chat_message(User.t(), User.t(), String.t(), list()) ::
	{:ok, Activity.t()} \| Pipeline.errors()
	def post_chat_message(%User{} = user, %User{} = recipient, content, opts \\ []) do
	with maybe_attachment <- opts[:media_id] && Object.get_by_id(opts[:media_id]),
	:ok <- validate_chat_attachment_attribution(maybe_attachment, user),
	:ok <- validate_chat_content_length(content, !!maybe_attachment),
	{_, {:ok, chat_message_data, _meta}} <-
	{:build_object,
	Builder.chat_message(
	user,
	recipient.ap_id,
	content \|> format_chat_content,
	attachment: maybe_attachment
	)},
	{_, {:ok, create_activity_data, _meta}} <-
	{:build_create_activity, Builder.create(user, chat_message_data, [recipient.ap_id])},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(create_activity_data,
	local: true,
	idempotency_key: opts[:idempotency_key]
	)} do
	{:ok, activity}
	else
	{:common_pipeline, e} -> e
	e -> e
	end
	end

	defp format_chat_content(nil), do: nil

	defp format_chat_content(content) do
	{text, _, _} =
	content
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify()
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()

	text
	end

	defp validate_chat_attachment_attribution(nil, _), do: :ok

	defp validate_chat_attachment_attribution(attachment, user) do
	with :ok <- Object.authorize_access(attachment, user) do
	:ok
	else
	e ->
	e
	end
	end

	defp validate_chat_content_length(_, true), do: :ok
	defp validate_chat_content_length(nil, false), do: {:error, :no_content}

	defp validate_chat_content_length(content, _) do
	if String.length(content) <= Pleroma.Config.get([:instance, :chat_limit]) do
	:ok
	else
	{:error, :content_too_long}
	end
	end

	@spec unblock(User.t(), User.t()) ::
	{:ok, Activity.t()} \| {:ok, :no_activity} \| Pipeline.errors() \| {:error, :not_blocking}
	def unblock(blocked, blocker) do
	with {_, %Activity{} = block} <- {:fetch_block, Utils.fetch_latest_block(blocker, blocked)},
	{:ok, unblock_data, _} <- Builder.undo(blocker, block),
	{:ok, unblock, _} <- Pipeline.common_pipeline(unblock_data, local: true) do
	{:ok, unblock}
	else
	{:fetch_block, nil} ->
	if User.blocks?(blocker, blocked) do
	User.unblock(blocker, blocked)
	{:ok, :no_activity}
	else
	{:error, :not_blocking}
	end

	e ->
	e
	end
	end

	@spec follow(User.t(), User.t()) ::
	{:ok, User.t(), User.t(), Activity.t() \| Object.t()}
	\| {:error, :rejected}
	\| Pipeline.errors()
	def follow(followed, follower) do
	timeout = Pleroma.Config.get([:activitypub, :follow_handshake_timeout])

	with {:ok, follow_data, _} <- Builder.follow(follower, followed),
	{:ok, activity, _} <- Pipeline.common_pipeline(follow_data, local: true),
	{:ok, follower, followed} <- User.wait_and_refresh(timeout, follower, followed) do
	if activity.data["state"] == "reject" do
	{:error, :rejected}
	else
	{:ok, followed, follower, activity}
	end
	end
	end

	@spec unfollow(User.t(), User.t()) :: {:ok, User.t()} \| {:error, any()}
	def unfollow(unfollowed, follower) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed),
	{:ok, _subscription} <- User.unsubscribe(follower, unfollowed),
	{:ok, _endorsement} <- User.unendorse(follower, unfollowed) do
	{:ok, follower}
	end
	end

	@spec accept_follow_request(User.t(), User.t()) :: {:ok, User.t()} \| Pipeline.errors()
	def accept_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, accept_data, _} <- Builder.accept(followed, follow_activity),
	{:ok, _activity, _} <- Pipeline.common_pipeline(accept_data, local: true) do
	{:ok, follower}
	end
	end

	@spec reject_follow_request(User.t(), User.t()) :: {:ok, User.t()} \| Pipeline.errors() \| nil
	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, reject_data, _} <- Builder.reject(followed, follow_activity),
	{:ok, _activity, _} <- Pipeline.common_pipeline(reject_data, local: true) do
	{:ok, follower}
	end
	end

	@spec delete(String.t(), User.t()) ::
	{:ok, Activity.t()} \| Pipeline.errors() \| {:error, :not_found \| String.t()}
	def delete(activity_id, user) do
	with {_, %Activity{data: %{"object" => _, "type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(activity_id, filter: [])},
	{_, {:ok, _}} <- {:cancel_jobs, maybe_cancel_jobs(activity)},
	{_, %Object{} = object, _} <-
	{:find_object, Object.normalize(activity, fetch: false), activity},
	true <- User.privileged?(user, :messages_delete) \|\| user.ap_id == object.data["actor"],
	{:ok, delete_data, _} <- Builder.delete(user, object.data["id"]),
	{:ok, delete, _} <- Pipeline.common_pipeline(delete_data, local: true) do
	if User.privileged?(user, :messages_delete) and user.ap_id != object.data["actor"] do
	action =
	if object.data["type"] == "ChatMessage" do
	"chat_message_delete"
	else
	"status_delete"
	end

	ModerationLog.insert_log(%{
	action: action,
	actor: user,
	subject_id: activity_id
	})
	end

	{:ok, delete}
	else
	{:find_activity, _} ->
	{:error, :not_found}

	{:find_object, nil, %Activity{data: %{"actor" => actor, "object" => object}}} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(actor, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete(activity_id, user)
	else
	_ ->
	Logger.error(
	"Could not insert tombstone for missing object on deletion. Object is #{object}."
	)

	{:error, dgettext("errors", "Could not delete")}
	end

	_ ->
	{:error, dgettext("errors", "Could not delete")}
	end
	end

	@spec repeat(String.t(), User.t(), map()) :: {:ok, Activity.t()} \| {:error, :not_found}
	def repeat(id, user, params \\ %{}) do
	with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id),
	object = %Object{} <- Object.normalize(activity, fetch: false),
	{_, nil} <- {:existing_announce, Utils.get_existing_announce(user.ap_id, object)},
	visibility = announce_visibility(object, params),
	{:ok, announce, _} <- Builder.announce(user, object, visibility: visibility),
	{:ok, activity, _} <- Pipeline.common_pipeline(announce, local: true) do
	{:ok, activity}
	else
	{:existing_announce, %Activity{} = announce} ->
	{:ok, announce}

	_ ->
	{:error, :not_found}
	end
	end

	@spec unrepeat(String.t(), User.t()) :: {:ok, Activity.t()} \| {:error, :not_found \| String.t()}
	def unrepeat(id, user) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)},
	%Object{} = note <- Object.normalize(activity, fetch: false),
	%Activity{} = announce <- Utils.get_existing_announce(user.ap_id, note),
	{_, {:ok, _}} <- {:cancel_jobs, maybe_cancel_jobs(announce)},
	{:ok, undo, _} <- Builder.undo(user, announce),
	{:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
	{:ok, activity}
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unrepeat")}
	end
	end

	@spec favorite(String.t(), User.t()) ::
	{:ok, Activity.t()} \| {:ok, :already_liked} \| {:error, :not_found \| String.t()}
	def favorite(id, %User{} = user) do
	case favorite_helper(user, id) do
	{:ok, _} = res ->
	res

	{:error, :not_found} = res ->
	res

	{:error, e} ->
	Logger.error("Could not favorite #{id}. Error: #{inspect(e, pretty: true)}")
	{:error, dgettext("errors", "Could not favorite")}
	end
	end

	defp favorite_helper(user, id) do
	with {_, %Activity{object: object}} <- {:find_object, Activity.get_by_id_with_object(id)},
	{_, true} <- {:visibility_error, activity_visible_to_actor(object, user)},
	{_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
	{:ok, activity}
	else
	{:find_object, _} ->
	{:error, :not_found}

	{:visibility_error, _} ->
	{:error, :not_found}

	{:common_pipeline, {:error, {:validate, {:error, changeset}}}} = e ->
	if {:object, {"already liked by this actor", []}} in changeset.errors do
	{:ok, :already_liked}
	else
	{:error, e}
	end

	e ->
	{:error, e}
	end
	end

	@spec unfavorite(String.t(), User.t()) ::
	{:ok, Activity.t()} \| {:error, :not_found \| String.t()}
	def unfavorite(id, user) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)},
	%Object{} = note <- Object.normalize(activity, fetch: false),
	{_, true} <- {:visibility_error, activity_visible_to_actor(note, user)},
	%Activity{} = like <- Utils.get_existing_like(user.ap_id, note),
	{_, {:ok, _}} <- {:cancel_jobs, maybe_cancel_jobs(like)},
	{:ok, undo, _} <- Builder.undo(user, like),
	{:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
	{:ok, activity}
	else
	{:find_activity, _} -> {:error, :not_found}
	{:visibility_error, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unfavorite")}
	end
	end

	@spec react_with_emoji(String.t(), User.t(), String.t()) ::
	{:ok, Activity.t()} \| {:error, String.t()}
	def react_with_emoji(id, user, emoji) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{_, true} <- {:visibility_error, activity_visible_to_actor(activity, user)},
	object <- Object.normalize(activity, fetch: false),
	{:ok, emoji_react, _} <- Builder.emoji_react(user, object, emoji),
	{:ok, activity, _} <- Pipeline.common_pipeline(emoji_react, local: true) do
	{:ok, activity}
	else
	{:visibility_error, _} ->
	{:error, :not_found}

	_ ->
	{:error, dgettext("errors", "Could not add reaction emoji")}
	end
	end

	@spec unreact_with_emoji(String.t(), User.t(), String.t()) ::
	{:ok, Activity.t()} \| {:error, String.t()}
	def unreact_with_emoji(id, user, emoji) do
	with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji),
	{_, {:ok, _}} <- {:cancel_jobs, maybe_cancel_jobs(reaction_activity)},
	{:ok, undo, _} <- Builder.undo(user, reaction_activity),
	{:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
	{:ok, activity}
	else
	_ ->
	{:error, dgettext("errors", "Could not remove reaction emoji")}
	end
	end

	@spec vote(Object.t(), User.t(), list()) :: {:ok, list(), Object.t()} \| Pipeline.errors()
	def vote(%Object{data: %{"type" => "Question"}} = object, %User{} = user, choices) do
	with :ok <- validate_not_author(object, user),
	:ok <- validate_existing_votes(user, object),
	{:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
	answer_activities =
	Enum.map(choices, fn index ->
	{:ok, answer_object, _meta} =
	Builder.answer(user, object, Enum.at(options, index)["name"])

	{:ok, activity_data, _meta} = Builder.create(user, answer_object, [])

	{:ok, activity, _meta} =
	activity_data
	\|> Map.put("cc", answer_object["cc"])
	\|> Map.put("context", answer_object["context"])
	\|> Pipeline.common_pipeline(local: true)

	# TODO: Do preload of Pleroma.Object in Pipeline
	Activity.normalize(activity.data)
	end)

	object = Object.get_cached_by_ap_id(object.data["id"])
	{:ok, answer_activities, object}
	end
	end

	defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
	do: {:error, dgettext("errors", "Poll's author can't vote")}

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

	defp validate_existing_votes(%{ap_id: ap_id}, object) do
	if Utils.get_existing_votes(ap_id, object) == [] do
	:ok
	else
	{:error, dgettext("errors", "Already voted")}
	end
	end

	defp get_options_and_max_count(%{data: %{"anyOf" => any_of}})
	when is_list(any_of) and any_of != [],
	do: {any_of, Enum.count(any_of)}

	defp get_options_and_max_count(%{data: %{"oneOf" => one_of}})
	when is_list(one_of) and one_of != [],
	do: {one_of, 1}

	defp normalize_and_validate_choices(choices, object) do
	choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
	{options, max_count} = get_options_and_max_count(object)
	count = Enum.count(options)

	with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
	{_, true} <- {:count_check, Enum.count(choices) <= max_count} do
	{:ok, options, choices}
	else
	{:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
	{:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
	end
	end

	def announce_visibility(_, %{visibility: visibility})
	when visibility in ~w{public unlisted private direct local},
	do: visibility

	def announce_visibility(object, _), do: Visibility.get_visibility(object)

	@spec get_visibility(map(), map() \| nil, Participation.t() \| nil) ::
	{String.t() \| nil, String.t() \| nil}
	def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}

	def get_visibility(%{visibility: visibility}, in_reply_to, _)
	when visibility in ~w{public local unlisted private direct},
	do: {visibility, get_replied_to_visibility(in_reply_to)}

	def get_visibility(%{visibility: "list:" <> list_id}, in_reply_to, _) do
	visibility = {:list, String.to_integer(list_id)}
	{visibility, get_replied_to_visibility(in_reply_to)}
	end

	def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
	visibility = get_replied_to_visibility(in_reply_to)
	{visibility, visibility}
	end

	def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}

	@spec get_replied_to_visibility(Activity.t() \| nil) :: String.t() \| nil
	def get_replied_to_visibility(nil), do: nil

	def get_replied_to_visibility(activity) do
	with %Object{} = object <- Object.normalize(activity, fetch: false) do
	Visibility.get_visibility(object)
	end
	end

	@spec check_expiry_date({:ok, nil \| integer()} \| String.t()) ::
	{:ok, boolean() \| nil} \| {:error, String.t()}
	def check_expiry_date({:ok, nil} = res), do: res

	def check_expiry_date({:ok, in_seconds}) do
	expiry = DateTime.add(DateTime.utc_now(), in_seconds)

	- if Pleroma.Workers.PurgeExpiredActivity.expires_late_enough?(expiry) do
	- {:ok, expiry}
	- else
	- {:error, "Expiry date is too soon"}
	+ cond do
	+ not Pleroma.Config.get([Pleroma.Workers.PurgeExpiredActivity, :enabled], false) ->
	+ {:error, :expired_activities_disabled}
	+
	+ not Pleroma.Workers.PurgeExpiredActivity.expires_late_enough?(expiry) ->
	+ {:error, "Expiry date is too soon"}
	+
	+ true ->
	+ {:ok, expiry}
	end
	end

	def check_expiry_date(expiry_str) do
	Ecto.Type.cast(:integer, expiry_str)
	\|> check_expiry_date()
	end

	@spec listen(User.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(user, data) do
	with {:ok, draft} <- ActivityDraft.listen(user, data) do
	ActivityPub.listen(draft.changes)
	end
	end

	@spec post(User.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	def post(user, %{status: _} = data) do
	with {:ok, draft} <- ActivityDraft.create(user, data) do
	- ActivityPub.create(draft.changes, draft.preview?)
	+ create_status(draft)
	+ end
	+ end
	+
	+ defp create_status(%ActivityDraft{preview?: true, changes: changes}) do
	+ ActivityPub.insert(changes, _local = true, _fake = true)
	+ end
	+
	+ defp create_status(%ActivityDraft{changes: changes}) do
	+ case Pipeline.common_pipeline(changes, local: true) do
	+ {:ok, activity, _meta} -> {:ok, activity}
	+ error -> unwrap_pipeline_error(error)
	end
	end

	+ # Callers of post/2 expect the error shape of the old ActivityPub.create/2:
	+ # `{:error, {:reject, reason}}` for MRF rejections and `{:error, reason}`
	+ # otherwise, without the pipeline stage wrapping.
	+ @pipeline_stages [:validate, :mrf, :persist, :side_effects, :federation]
	+
	+ defp unwrap_pipeline_error({:reject, reason}), do: {:error, {:reject, reason}}
	+
	+ defp unwrap_pipeline_error({:error, {stage, error}}) when stage in @pipeline_stages,
	+ do: unwrap_pipeline_error(error)
	+
	+ defp unwrap_pipeline_error({:error, {:error, _} = error}), do: unwrap_pipeline_error(error)
	+ defp unwrap_pipeline_error({:error, _} = error), do: error
	+ defp unwrap_pipeline_error(error), do: {:error, error}
	+
	@spec update(Activity.t(), User.t(), map()) :: {:ok, Activity.t()} \| {:error, nil}
	def update(orig_activity, %User{} = user, changes) do
	with orig_object <- Object.normalize(orig_activity),
	{:ok, new_object} <- make_update_data(user, orig_object, changes),
	{:ok, update_data, _} <- Builder.update(user, new_object),
	{:ok, update, _} <- Pipeline.common_pipeline(update_data, local: true) do
	{:ok, update}
	else
	_ -> {:error, nil}
	end
	end

	defp make_update_data(user, orig_object, changes) do
	kept_params = %{
	visibility: Visibility.get_visibility(orig_object),
	in_reply_to_id:
	with replied_id when is_binary(replied_id) <- orig_object.data["inReplyTo"],
	%Activity{id: activity_id} <- Activity.get_create_by_object_ap_id(replied_id) do
	activity_id
	else
	_ -> nil
	end
	}

	params = Map.merge(changes, kept_params)

	with {:ok, draft} <- ActivityDraft.create(user, params) do
	change =
	Object.Updater.make_update_object_data(orig_object.data, draft.object, Utils.make_date())

	{:ok, change}
	else
	_ -> {:error, nil}
	end
	end

	@spec pin(String.t(), User.t()) :: {:ok, Activity.t()} \| Pipeline.errors()
	def pin(id, %User{} = user) do
	with %Activity{} = activity <- create_activity_by_id(id),
	true <- activity_visible_to_actor(activity, user),
	true <- activity_belongs_to_actor(activity, user.ap_id),
	true <- object_type_is_allowed_for_pin(activity.object),
	true <- activity_is_public(activity),
	{:ok, pin_data, _} <- Builder.pin(user, activity.object),
	{:ok, _pin, _} <-
	Pipeline.common_pipeline(pin_data,
	local: true,
	activity_id: id
	) do
	{:ok, activity}
	else
	{:error, {:side_effects, error}} -> error
	error -> error
	end
	end

	defp create_activity_by_id(id) do
	with nil <- Activity.create_by_id_with_object(id) do
	{:error, :not_found}
	end
	end

	defp activity_belongs_to_actor(%{actor: actor}, actor), do: true
	defp activity_belongs_to_actor(_, _), do: {:error, :ownership_error}

	defp activity_visible_to_actor(activity, %User{} = user) do
	if Visibility.visible_for_user?(activity, user) do
	true
	else
	{:error, :visibility_error}
	end
	end

	defp object_type_is_allowed_for_pin(%{data: %{"type" => type}}) do
	with false <- type in ["Note", "Article", "Question"] do
	{:error, :not_allowed}
	end
	end

	defp activity_is_public(activity) do
	with false <- Visibility.public?(activity) do
	{:error, :non_public_error}
	end
	end

	@spec unpin(String.t(), User.t()) :: {:ok, Activity.t()} \| Pipeline.errors()
	def unpin(id, user) do
	# Order of visibility/belonging matters for MastoAPI responses.
	# post not visible -> 404
	# post visible, not owned -> 422
	with %Activity{} = activity <- create_activity_by_id(id),
	true <- activity_visible_to_actor(activity, user),
	true <- activity_belongs_to_actor(activity, user.ap_id),
	{:ok, unpin_data, _} <- Builder.unpin(user, activity.object),
	{:ok, _unpin, _} <-
	Pipeline.common_pipeline(unpin_data,
	local: true,
	activity_id: activity.id,
	expires_at: activity.data["expires_at"],
	featured_address: user.featured_address
	) do
	{:ok, activity}
	end
	end

	@spec add_mute(Activity.t(), User.t(), map()) :: {:ok, Activity.t()} \| {:error, String.t()}
	def add_mute(activity, user, params \\ %{}) do
	expires_in = Map.get(params, :expires_in, 0)

	with true <- activity_visible_to_actor(activity, user),
	{:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]),
	_ <- Pleroma.Notification.mark_context_as_read(user, activity.data["context"]) do
	if expires_in > 0 do
	Pleroma.Workers.MuteExpireWorker.new(
	%{"op" => "unmute_conversation", "user_id" => user.id, "activity_id" => activity.id},
	schedule_in: expires_in
	)
	\|> Oban.insert()
	end

	{:ok, activity}
	else
	{:error, :visibility_error} -> {:error, :visibility_error}
	{:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
	end
	end

	@spec remove_mute(Activity.t(), User.t()) :: {:ok, Activity.t()} \| {:error, any()}
	def remove_mute(%Activity{} = activity, %User{} = user) do
	case activity_visible_to_actor(activity, user) do
	true ->
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}

	error ->
	error
	end
	end

	@spec remove_mute(String.t(), String.t()) :: {:ok, Activity.t()} \| {:error, any()}
	def remove_mute(activity_id, user_id) do
	with {:user, %User{} = user} <- {:user, User.get_by_id(user_id)},
	{:activity, %Activity{} = activity} <- {:activity, Activity.get_by_id(activity_id)} do
	remove_mute(activity, user)
	else
	{what, result} = error ->
	Logger.warning(
	"CommonAPI.remove_mute/2 failed. #{what}: #{result}, user_id: #{user_id}, activity_id: #{activity_id}"
	)

	{:error, error}
	end
	end

	@spec thread_muted?(Activity.t(), User.t()) :: boolean()
	def thread_muted?(%{data: %{"context" => context}}, %User{id: user_id})
	when is_binary(context) do
	ThreadMute.exists?(user_id, context)
	end

	def thread_muted?(_, _), do: false

	@spec report(User.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	def report(user, data) do
	with {:ok, account} <- get_reported_account(data.account_id),
	{:ok, {content_html, _, _}} <- make_report_content_html(data[:comment]),
	{:ok, statuses} <- get_report_statuses(account, data),
	true <- check_statuses_visibility(user, statuses),
	rules <- get_report_rules(Map.get(data, :rule_ids, nil)) do
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: Map.get(data, :forward, false),
	rules: rules
	})
	else
	false ->
	{:error, :visibility_error}

	error ->
	error
	end
	end

	defp check_statuses_visibility(user, statuses) when is_list(statuses) do
	visibility = for status <- statuses, do: Visibility.visible_for_user?(status, user)

	case Enum.all?(visibility) do
	true -> true
	_ -> false
	end
	end

	# There are no statuses associated with the report, pass!
	defp check_statuses_visibility(_, status) when status == nil, do: true

	defp get_reported_account(account_id) do
	case User.get_cached_by_id(account_id) do
	%User{} = account -> {:ok, account}
	_ -> {:error, dgettext("errors", "Account not found")}
	end
	end

	defp get_report_rules(nil) do
	nil
	end

	defp get_report_rules(rule_ids) do
	rule_ids
	\|> Enum.filter(&Rule.exists?/1)
	end

	@spec update_report_state(String.t() \| [String.t()], String.t()) ::
	{:ok, any()} \| {:error, any()}
	def update_report_state(activity_ids, state) when is_list(activity_ids) do
	case Utils.update_report_state(activity_ids, state) do
	:ok -> {:ok, activity_ids}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_report_state(activity_id, state) do
	with %Activity{} = activity <- Activity.get_report(activity_id) do
	Utils.update_report_state(activity, state)
	else
	nil -> {:error, :not_found}
	end
	end

	def assign_report_to_account(activity_ids, user) when is_list(activity_ids) do
	case Utils.assign_report_to_account(activity_ids, user) do
	:ok -> {:ok, activity_ids}
	_ -> {:error, dgettext("errors", "Could not assign account")}
	end
	end

	def assign_report_to_account(activity_id, user) do
	with %Activity{} = activity <- Activity.get_report(activity_id) do
	Utils.assign_report_to_account(activity, user)
	else
	nil -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not assign account")}
	end
	end

	@spec update_activity_scope(String.t(), map()) :: {:ok, any()} \| {:error, any()}
	def update_activity_scope(activity_id, opts \\ %{}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
	{:ok, activity} <- toggle_sensitive(activity, opts) do
	set_visibility(activity, opts)
	else
	nil -> {:error, :not_found}
	end
	end

	defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
	toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
	end

	defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
	when is_boolean(sensitive) do
	new_data = Map.put(object.data, "sensitive", sensitive)

	{:ok, object} =
	object
	\|> Object.change(%{data: new_data})
	\|> Object.update_and_set_cache()

	{:ok, Map.put(activity, :object, object)}
	end

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

	defp set_visibility(activity, %{visibility: visibility}) do
	Utils.update_activity_visibility(activity, visibility)
	end

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

	@spec hide_reblogs(User.t(), User.t()) :: {:ok, any()} \| {:error, any()}
	def hide_reblogs(%User{} = target, %User{} = user) do
	UserRelationship.create_reblog_mute(user, target)
	end

	@spec show_reblogs(User.t(), User.t()) :: {:ok, any()} \| {:error, any()}
	def show_reblogs(%User{} = target, %User{} = user) do
	UserRelationship.delete_reblog_mute(user, target)
	end

	@spec get_user(String.t(), boolean()) :: User.t() \| nil
	def get_user(ap_id, fake_record_fallback \\ true) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	fake_record_fallback ->
	# TODO: refactor (fake records is never a good idea)
	User.error_user(ap_id)

	true ->
	nil
	end
	end

	defp maybe_cancel_jobs(%Activity{id: activity_id}) do
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^activity_id)
	\|> Oban.cancel_all_jobs()
	end

	defp maybe_cancel_jobs(_), do: {:ok, 0}
	end
	diff --git a/lib/pleroma/web/common_api/activity_draft.ex b/lib/pleroma/web/common_api/activity_draft.ex
	index 6072fff6b..63207e462 100644
	--- a/lib/pleroma/web/common_api/activity_draft.ex
	+++ b/lib/pleroma/web/common_api/activity_draft.ex
	@@ -1,377 +1,410 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.ActivityDraft do
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Language.LanguageDetector
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils

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

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

	@type t :: %__MODULE__{}

	defstruct valid?: true,
	errors: [],
	user: nil,
	params: %{},
	status: nil,
	summary: nil,
	full_payload: nil,
	attachments: [],
	in_reply_to: nil,
	in_reply_to_conversation: nil,
	quote_post: nil,
	visibility: nil,
	expires_at: nil,
	extra: nil,
	emoji: %{},
	content_html: nil,
	mentions: [],
	tags: [],
	to: [],
	cc: [],
	context: nil,
	sensitive: false,
	language: nil,
	object: nil,
	preview?: false,
	changes: %{}

	def new(user, params) do
	%__MODULE__{user: user}
	\|> put_params(params)
	end

	def create(user, params) do
	user
	\|> new(params)
	\|> status()
	\|> summary()
	\|> with_valid(&attachments/1)
	\|> full_payload()
	\|> expires_at()
	\|> poll()
	\|> with_valid(&in_reply_to/1)
	\|> with_valid(&in_reply_to_conversation/1)
	\|> with_valid(&quote_post/1)
	\|> with_valid(&visibility/1)
	\|> with_valid(&quoting_visibility/1)
	\|> content()
	\|> with_valid(&to_and_cc/1)
	\|> with_valid(&context/1)
	\|> with_valid(&language/1)
	\|> sensitive()
	\|> with_valid(&object/1)
	\|> preview?()
	\|> with_valid(&changes/1)
	\|> validate()
	end

	def listen(user, params) do
	user
	\|> new(params)
	\|> visibility()
	\|> to_and_cc()
	\|> context()
	\|> listen_object()
	- \|> with_valid(&changes/1)
	+ \|> with_valid(&listen_changes/1)
	\|> validate()
	end

	defp listen_object(%__MODULE__{} = draft) do
	object =
	draft.params
	\|> Map.take([:album, :artist, :title, :length])
	\|> Map.put(:externalLink, Map.get(draft.params, :external_link))
	\|> Map.new(fn {key, value} -> {to_string(key), value} end)
	\|> Map.put("type", "Audio")
	\|> Map.put("to", draft.to)
	\|> Map.put("cc", draft.cc)
	\|> Map.put("actor", draft.user.ap_id)

	%{draft \| object: object}
	end

	defp put_params(%__MODULE__{} = draft, params) do
	params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
	%{draft \| params: params}
	end

	defp status(%__MODULE__{params: %{status: status}} = draft) do
	%{draft \| status: String.trim(status)}
	end

	defp summary(%__MODULE__{params: params} = draft) do
	%{draft \| summary: Map.get(params, :spoiler_text, "")}
	end

	defp full_payload(%__MODULE__{status: status, summary: summary} = draft) do
	full_payload = String.trim(status <> summary)

	case Utils.validate_character_limit(full_payload, draft.attachments) do
	:ok -> %{draft \| full_payload: full_payload}
	{:error, message} -> add_error(draft, message)
	end
	end

	defp attachments(%__MODULE__{params: params} = draft) do
	attachments = Utils.attachments_from_ids(params, draft.user)
	draft = %{draft \| attachments: attachments}

	case Utils.validate_attachments_count(attachments) do
	:ok -> draft
	{:error, message} -> add_error(draft, message)
	end
	end

	defp in_reply_to(%__MODULE__{params: %{in_reply_to_status_id: ""}} = draft), do: draft

	defp in_reply_to(%__MODULE__{params: %{in_reply_to_status_id: id}} = draft)
	when is_binary(id) do
	# If a post was deleted all its activities (except the newly added Delete) are purged too,
	# thus lookup by Create db ID will yield nil just as if it never existed in the first place.
	#
	# We allow replying to Announce here, due to a Pleroma-FE quirk where if presented with
	# an Announce id it will render it as if it was just the normal referenced post, but
	# use the Announce id for replies in the in_reply_to_id key of a POST request to
	# /api/v1/statuses, or as an :id in /api/v1/statuses/:id/*.
	# TODO: Fix this quirk in FE and remove here and other affected places
	with %Activity{} = activity <- Activity.get_by_id(id),
	true <- Visibility.visible_for_user?(activity, draft.user),
	{_, type} when type in ["Create", "Announce"] <- {:type, activity.data["type"]} do
	%{draft \| in_reply_to: activity}
	else
	nil ->
	add_error(draft, dgettext("errors", "Cannot reply to a deleted status"))

	false ->
	add_error(draft, dgettext("errors", "Record not found"))

	{:type, type} ->
	add_error(
	draft,
	dgettext("errors", "Can only reply to posts, not %{type} activities",
	type: inspect(type)
	)
	)
	end
	end

	defp in_reply_to(
	%__MODULE__{params: %{in_reply_to_status_id: %Activity{} = in_reply_to}} = draft
	) do
	%{draft \| in_reply_to: in_reply_to}
	end

	defp in_reply_to(draft), do: draft

	defp quote_post(%__MODULE__{params: %{quoted_status_id: id}} = draft)
	when not_empty_string(id) do
	case Activity.get_by_id_with_object(id) do
	%Activity{} = activity ->
	%{draft \| quote_post: activity}

	_ ->
	draft
	end
	end

	defp quote_post(%__MODULE__{params: %{quote_id: id}} = draft) when not_empty_string(id) do
	quote_post(%{draft \| params: Map.put(draft.params, :quoted_status_id, id)})
	end

	defp quote_post(draft), do: draft

	defp in_reply_to_conversation(%__MODULE__{} = draft) do
	in_reply_to_conversation = Participation.get(draft.params[:in_reply_to_conversation_id])
	%{draft \| in_reply_to_conversation: in_reply_to_conversation}
	end

	defp visibility(%__MODULE__{params: params} = draft) do
	case CommonAPI.get_visibility(params, draft.in_reply_to, draft.in_reply_to_conversation) do
	{visibility, "direct"} when visibility != "direct" ->
	add_error(draft, dgettext("errors", "The message visibility must be direct"))

	{visibility, _} ->
	%{draft \| visibility: visibility}
	end
	end

	defp can_quote?(_draft, _object, visibility) when visibility in ~w(public unlisted local) do
	true
	end

	defp can_quote?(draft, object, "private") do
	draft.user.ap_id == object.data["actor"]
	end

	defp can_quote?(_, _, _) do
	false
	end

	defp quoting_visibility(%__MODULE__{quote_post: %Activity{}} = draft) do
	with %Object{} = object <- Object.normalize(draft.quote_post, fetch: false),
	true <- can_quote?(draft, object, Visibility.get_visibility(object)) do
	draft
	else
	_ -> add_error(draft, dgettext("errors", "Cannot quote private message"))
	end
	end

	defp quoting_visibility(draft), do: draft

	defp expires_at(%__MODULE__{} = draft) do
	case CommonAPI.check_expiry_date(draft.params[:expires_in]) do
	{:ok, expires_at} -> %{draft \| expires_at: expires_at}
	{:error, message} -> add_error(draft, message)
	end
	end

	defp poll(%__MODULE__{} = draft) do
	case Utils.make_poll_data(draft.params) do
	{:ok, {poll, poll_emoji}} ->
	%{draft \| extra: poll, emoji: Map.merge(draft.emoji, poll_emoji)}

	{:error, message} ->
	add_error(draft, message)
	end
	end

	defp content(%__MODULE__{mentions: mentions} = draft) do
	{content_html, mentioned_users, tags} = Utils.make_content_html(draft)

	mentioned_ap_ids =
	Enum.map(mentioned_users, fn {_, mentioned_user} -> mentioned_user.ap_id end)

	mentions =
	mentions
	\|> Kernel.++(mentioned_ap_ids)
	\|> Utils.get_addressed_users(draft.params[:to])

	%{draft \| content_html: content_html, mentions: mentions, tags: tags}
	end

	defp to_and_cc(%__MODULE__{} = draft) do
	{to, cc} = Utils.get_to_and_cc(draft)
	+
	+ # Objects must be addressed to someone. Direct messages without mentions
	+ # are addressed to their author, who is a recipient anyway.
	+ cc = if to == [] and cc == [], do: [draft.user.ap_id], else: cc
	+
	%{draft \| to: to, cc: cc}
	end

	defp context(%__MODULE__{} = draft) do
	context = Utils.make_context(draft.in_reply_to, draft.in_reply_to_conversation)
	%{draft \| context: context}
	end

	defp sensitive(%__MODULE__{} = draft) do
	sensitive = draft.params[:sensitive]
	%{draft \| sensitive: sensitive}
	end

	defp language(%__MODULE__{} = draft) do
	language =
	with language <- draft.params[:language],
	true <- good_locale_code?(language) do
	language
	else
	_ -> LanguageDetector.detect(draft.content_html <> " " <> draft.summary)
	end

	%{draft \| language: language}
	end

	defp object(%__MODULE__{} = draft) do
	emoji = Map.merge(Pleroma.Emoji.Formatter.get_emoji_map(draft.full_payload), draft.emoji)

	# Sometimes people create posts with subject containing emoji,
	# since subjects are usually copied this will result in a broken
	# subject when someone replies from an instance that does not have
	# the emoji or has it under different shortcode. This is an attempt
	# to mitigate this by copying emoji from inReplyTo if they are present
	# in the subject.
	summary_emoji =
	with %Activity{} <- draft.in_reply_to,
	%Object{data: %{"tag" => [_ \| _] = tag}} <- Object.normalize(draft.in_reply_to) do
	Enum.reduce(tag, %{}, fn
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}, acc ->
	if String.contains?(draft.summary, name) do
	Map.put(acc, name, url)
	else
	acc
	end

	_, acc ->
	acc
	end)
	else
	_ -> %{}
	end

	emoji = Map.merge(emoji, summary_emoji)

	media_type = Utils.get_content_type(draft.params[:content_type])
	{:ok, note_data, _meta} = Builder.note(draft)

	object =
	note_data
	\|> Map.put("emoji", emoji)
	\|> Map.put("source", %{
	"content" => draft.status,
	"mediaType" => media_type
	})
	\|> maybe_put("htmlMfm", true, media_type == "text/x.misskeymarkdown")
	+ \|> maybe_put("directMessage", true, draft.visibility == "direct")
	\|> Map.put("generator", draft.params[:generator])
	\|> Map.put("language", draft.language)

	%{draft \| object: object}
	end

	defp maybe_put(map, key, value, true), do: Map.put(map, key, value)
	defp maybe_put(map, _key, _value, _condition), do: map

	defp preview?(%__MODULE__{} = draft) do
	preview? = Pleroma.Web.Utils.Params.truthy_param?(draft.params[:preview])
	%{draft \| preview?: preview?}
	end

	+ # Builds the Create activity for the pipeline.
	defp changes(%__MODULE__{} = draft) do
	- direct? = draft.visibility == "direct"
	- additional = %{"cc" => draft.cc, "directMessage" => direct?}
	+ {:ok, create_data, _meta} = Builder.create(draft.user, draft.object, draft.to)

	- additional =
	- case draft.expires_at do
	- %DateTime{} = expires_at -> Map.put(additional, "expires_at", expires_at)
	- _ -> additional
	- end
	+ changes =
	+ create_data
	+ \|> Map.put("cc", draft.cc)
	+ \|> Map.put("directMessage", draft.visibility == "direct")
	+ \|> maybe_put_expires_at(draft.expires_at)
	+ \|> maybe_add_list_data(draft.user, draft.visibility)
	+
	+ %{draft \| changes: changes}
	+ end
	+
	+ defp maybe_put_expires_at(data, %DateTime{} = expires_at),
	+ do: Map.put(data, "expires_at", DateTime.to_iso8601(expires_at))
	+
	+ defp maybe_put_expires_at(data, _), do: data
	+
	+ defp maybe_add_list_data(data, user, {:list, list_id}) do
	+ case Pleroma.List.get(list_id, user) do
	+ %Pleroma.List{ap_id: list_ap_id} ->
	+ data
	+ \|> Map.put("bcc", [list_ap_id])
	+ \|> Map.put("listMessage", list_ap_id)
	+ \|> put_in(["object", "bcc"], [list_ap_id])
	+ \|> put_in(["object", "listMessage"], list_ap_id)
	+
	+ _ ->
	+ data
	+ end
	+ end
	+
	+ defp maybe_add_list_data(data, _user, _visibility), do: data

	+ # Builds the params for ActivityPub.listen/1.
	+ defp listen_changes(%__MODULE__{} = draft) do
	changes =
	%{
	to: draft.to,
	actor: draft.user,
	context: draft.context,
	object: draft.object,
	- additional: additional
	+ additional: %{"cc" => draft.cc, "directMessage" => draft.visibility == "direct"}
	}
	\|> Utils.maybe_add_list_data(draft.user, draft.visibility)

	%{draft \| changes: changes}
	end

	defp with_valid(%{valid?: true} = draft, func), do: func.(draft)
	defp with_valid(draft, _func), do: draft

	defp add_error(%__MODULE__{} = draft, message) do
	%{draft \| valid?: false, errors: [message \| draft.errors]}
	end

	defp validate(%{valid?: true} = draft), do: {:ok, draft}
	defp validate(%{errors: [message \| _]}), do: {:error, message}
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	index 6cd7469f9..f0ae50fcd 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	@@ -1,732 +1,737 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [try_render: 3, add_link_headers: 2]

	require Ecto.Query
	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.BookmarkFolder
	alias Pleroma.Language.Translation
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.ScheduledActivityView
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)

	plug(:skip_public_check when action in [:index, :show])

	@unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}

	plug(
	OAuthScopesPlug,
	%{@unauthenticated_access \| scopes: ["read:statuses"]}
	when action in [
	:index,
	:show,
	:context,
	:show_history,
	:show_source,
	:quotes
	]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:statuses"]} when action == :translate)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:statuses"]}
	when action in [
	:create,
	:delete,
	:reblog,
	:unreblog,
	:update
	]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:favourites"]} when action == :favourites)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:favourites"]} when action in [:favourite, :unfavourite]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:mutes"]} when action in [:mute_conversation, :unmute_conversation]
	)

	plug(
	OAuthScopesPlug,
	%{@unauthenticated_access \| scopes: ["read:accounts"]}
	when action in [:favourited_by, :reblogged_by]
	)

	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action in [:pin, :unpin])

	plug(OAuthScopesPlug, %{scopes: ["read:bookmarks"]} when action == :bookmarks)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:bookmarks"]} when action in [:bookmark, :unbookmark]
	)

	@rate_limited_status_actions ~w(reblog unreblog favourite unfavourite create delete translate)a

	plug(
	RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:reblog_unreblog", params: [:id]]
	when action in ~w(reblog unreblog)a
	)

	plug(
	RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:fav_unfav", params: [:id]]
	when action in ~w(favourite unfavourite)a
	)

	plug(RateLimiter, [name: :statuses_actions] when action in @rate_limited_status_actions)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.StatusOperation

	@doc """
	GET `/api/v1/statuses?ids[]=1&ids[]=2`

	`ids` query param is required
	"""
	def index(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: params}}} =
	conn,
	_
	) do
	ids = Map.get(params, :id, Map.get(params, :ids))
	limit = 100

	activities =
	ids
	\|> Enum.take(limit)
	\|> Activity.all_by_ids_with_object()
	\|> Enum.filter(&Visibility.visible_for_user?(&1, user))

	render(conn, "index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end

	@doc """
	POST /api/v1/statuses
	"""
	# Creates a scheduled status when `scheduled_at` param is present and it's far enough
	def create(
	%{
	assigns: %{user: user},
	private: %{
	open_api_spex: %{body_params: %{status: _, scheduled_at: scheduled_at} = params}
	}
	} = conn,
	_
	)
	when not is_nil(scheduled_at) do
	params =
	Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
	\|> put_application(conn)

	attrs = %{
	params: Map.new(params, fn {key, value} -> {to_string(key), value} end),
	scheduled_at: scheduled_at
	}

	with {:far_enough, true} <- {:far_enough, ScheduledActivity.far_enough?(scheduled_at)},
	{:ok, scheduled_activity} <- ScheduledActivity.create(user, attrs) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", scheduled_activity: scheduled_activity)
	else
	{:far_enough, _} ->
	params = Map.drop(params, [:scheduled_at])

	put_in(
	conn,
	[Access.key(:private), Access.key(:open_api_spex), Access.key(:body_params)],
	params
	)
	\|> do_create

	error ->
	error
	end
	end

	# Creates a regular status
	def create(
	%{
	private: %{open_api_spex: %{body_params: %{status: _}}}
	} = conn,
	_
	) do
	do_create(conn)
	end

	def create(
	%{
	assigns: %{user: _user},
	private: %{open_api_spex: %{body_params: %{media_ids: _} = params}}
	} = conn,
	_
	) do
	params = Map.put(params, :status, "")

	put_in(
	conn,
	[Access.key(:private), Access.key(:open_api_spex), Access.key(:body_params)],
	params
	)
	\|> do_create
	end

	defp do_create(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: params}}} = conn
	) do
	params =
	Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
	\|> put_application(conn)

	with {:ok, activity} <- CommonAPI.post(user, params) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	as: :activity,
	with_direct_conversation_id: true
	)
	else
	{:error, {:reject, message}} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})

	{:error, message} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})
	end
	end

	@doc "GET /api/v1/statuses/:id/history"
	def show_history(
	%{assigns: assigns, private: %{open_api_spex: %{params: %{id: id} = params}}} = conn,
	_
	) do
	with user = assigns[:user],
	%Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "history.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "GET /api/v1/statuses/:id/source"
	def show_source(%{assigns: assigns, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	with user = assigns[:user],
	%Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "source.json",
	activity: activity,
	for: user
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "PUT /api/v1/statuses/:id"
	def update(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: body_params, params: %{id: id} = params}}
	} = conn,
	_
	) do
	with {_, %Activity{}} = {_, activity} <- {:activity, Activity.get_by_id_with_object(id)},
	{_, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	{_, true} <- {:is_create, activity.data["type"] == "Create"},
	actor <- Activity.user_actor(activity),
	{_, true} <- {:own_status, actor.id == user.id},
	changes <- body_params \|> put_application(conn),
	{_, {:ok, _update_activity}} <- {:pipeline, CommonAPI.update(activity, user, changes)},
	{_, %Activity{}} = {_, activity} <- {:refetched, Activity.get_by_id_with_object(id)} do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	{:own_status, _} -> {:error, :forbidden}
	{:pipeline, _} -> {:error, :internal_server_error}
	_ -> {:error, :not_found}
	end
	end

	@doc "GET /api/v1/statuses/:id"
	def show(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id} = params}}} =
	conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "DELETE /api/v1/statuses/:id"
	def delete(%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	# CommonAPI already checks whether user is allowed to delete
	{:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_source: true
	)
	else
	_e -> {:error, :not_found}
	end
	end

	@doc "POST /api/v1/statuses/:id/reblog"
	def reblog(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: params, params: %{id: ap_id_or_id}}}
	} = conn,
	_
	) do
	with {:ok, announce} <- CommonAPI.repeat(ap_id_or_id, user, params),
	# CommonAPI already checks whether user is allowed to reblog
	%Activity{} = announce <- Activity.normalize(announce.data) do
	try_render(conn, "show.json", %{activity: announce, for: user, as: :activity})
	end
	end

	@doc "POST /api/v1/statuses/:id/unreblog"
	def unreblog(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: activity_id}}}} =
	conn,
	_
	) do
	with {:ok, _unannounce} <- CommonAPI.unrepeat(activity_id, user),
	%Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", %{activity: activity, for: user, as: :activity})
	end
	end

	@doc "POST /api/v1/statuses/:id/favourite"
	def favourite(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: activity_id}}}} =
	conn,
	_
	) do
	with {:ok, _fav} <- CommonAPI.favorite(activity_id, user),
	# CommonAPI already checks whether user is allowed to reblog
	%Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unfavourite"
	def unfavourite(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: activity_id}}}} =
	conn,
	_
	) do
	with {:ok, _unfav} <- CommonAPI.unfavorite(activity_id, user),
	%Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/pin"
	def pin(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: ap_id_or_id}}}} =
	conn,
	_
	) do
	with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	# Order matters, if status is not owned by user and is not visible to user
	# return 404 just like other endpoints
	{:error, :pinned_statuses_limit_reached} ->
	{:error, "You have already pinned the maximum number of statuses"}

	{:error, :ownership_error} ->
	{:error, :unprocessable_entity, "Someone else's status cannot be pinned"}

	{:error, :visibility_error} ->
	{:error, :not_found, "Record not found"}

	{:error, :non_public_error} ->
	{:error, :unprocessable_entity, "Non-public status cannot be pinned"}

	error ->
	error
	end
	end

	@doc "POST /api/v1/statuses/:id/unpin"
	def unpin(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: ap_id_or_id}}}} =
	conn,
	_
	) do
	# CommonAPI already checks whether user can unpin
	with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	# Order matters, if status is not owned by user and is not visible to user
	# return 404 just like other endpoints
	{:error, :visibility_error} ->
	{:error, :not_found, "Record not found"}

	{:error, :ownership_error} ->
	{:error, :unprocessable_entity, "Someone else's status cannot be unpinned"}

	error ->
	error
	end
	end

	@doc "POST /api/v1/statuses/:id/bookmark"
	def bookmark(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: body_params, params: %{id: id}}}
	} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	folder_id <- Map.get(body_params, :folder_id, nil),
	folder_id <-
	if(folder_id && BookmarkFolder.belongs_to_user?(folder_id, user.id),
	do: folder_id,
	else: nil
	),
	{:ok, _bookmark} <- Bookmark.create(user.id, activity.id, folder_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	false ->
	{:error, :not_found, "Record not found"}

	error ->
	error
	end
	end

	@doc "POST /api/v1/statuses/:id/unbookmark"
	def unbookmark(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _bookmark} <- Bookmark.destroy(user.id, activity.id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	false ->
	{:error, :not_found, "Record not found"}

	error ->
	error
	end
	end

	@doc "POST /api/v1/statuses/:id/mute"
	def mute_conversation(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: params, params: %{id: id}}}
	} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	# CommonAPI already checks whether user is allowed to mute
	{:ok, activity} <- CommonAPI.add_mute(activity, user, params) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	{:error, :visibility_error} ->
	{:error, :not_found, "Record not found"}

	error ->
	error
	end
	end

	@doc "POST /api/v1/statuses/:id/unmute"
	def unmute_conversation(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{params: %{id: id}}}
	} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	# CommonAPI already checks whether user is allowed to unmute
	{:ok, activity} <- CommonAPI.remove_mute(activity, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	{:error, :visibility_error} ->
	{:error, :not_found, "Record not found"}

	error ->
	error
	end
	end

	@doc "GET /api/v1/statuses/:id/favourited_by"
	def favourited_by(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with true <- Pleroma.Config.get([:instance, :show_reactions]),
	%Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	%Object{data: %{"likes" => likes}} <- Object.normalize(activity, fetch: false) do
	users =
	User
	\|> Ecto.Query.where([u], u.ap_id in ^likes)
	\|> Ecto.Query.order_by([u], fragment("array_position(?, ?)", ^likes, u.ap_id))
	\|> Repo.all()
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	{:visible, false} -> {:error, :not_found}
	_ -> json(conn, [])
	end
	end

	@doc "GET /api/v1/statuses/:id/reblogged_by"
	def reblogged_by(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	%Object{data: %{"announcements" => announces, "id" => ap_id}} <-
	Object.normalize(activity, fetch: false) do
	announces =
	"Announce"
	\|> Activity.Queries.by_type()
	\|> Ecto.Query.where([a], a.actor in ^announces)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.all()
	\|> Enum.filter(&Visibility.visible_for_user?(&1, user))
	\|> Enum.map(& &1.actor)
	\|> Enum.uniq()

	users =
	User
	\|> Ecto.Query.where([u], u.ap_id in ^announces)
	\|> Ecto.Query.order_by([u], fragment("array_position(?, ?)", ^announces, u.ap_id))
	\|> Repo.all()
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	{:visible, false} -> {:error, :not_found}
	_ -> json(conn, [])
	end
	end

	@doc "GET /api/v1/statuses/:id/context"
	def context(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id(id) do
	activities =
	ActivityPub.fetch_activities_for_context(activity.data["context"], %{
	blocking_user: user,
	user: user,
	exclude_id: activity.id
	})

	render(conn, "context.json", activity: activity, activities: activities, user: user)
	end
	end

	@doc "POST /api/v1/statuses/:id/translate"
	def translate(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: params, params: %{id: status_id}}}
	} = conn,
	_
	) do
	with %Activity{object: object} <- Activity.get_by_id_with_object(status_id),
	{:visibility, visibility} when visibility in ["public", "unlisted"] <-
	{:visibility, Visibility.get_visibility(object)},
	{:language, language} when is_binary(language) <-
	{:language, Map.get(params, :lang) \|\| user.language},
	{:ok, result} <-
	Translation.translate(
	object.data["content"],
	object.data["language"],
	language
	) do
	render(conn, "translation.json", result)
	else
	{:language, nil} ->
	render_error(conn, :bad_request, "Language not specified")

	{:visibility, _} ->
	render_error(conn, :not_found, "Record not found")

	{:error, :not_found} ->
	render_error(conn, :not_found, "Translation service not configured")

	{:error, error} when error in [:unexpected_response, :quota_exceeded, :too_many_requests] ->
	render_error(conn, :service_unavailable, "Translation service not available")

	_ ->
	render_error(conn, :internal_server_error, "Translation failed")
	end
	end

	@doc "GET /api/v1/favourites"
	def favourites(
	%{assigns: %{user: %User{} = user}, private: %{open_api_spex: %{params: params}}} = conn,
	_
	) do
	activities = ActivityPub.fetch_favourites(user, params)

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	end

	@doc "GET /api/v1/bookmarks"
	def bookmarks(%{assigns: %{user: user}, private: %{open_api_spex: %{params: params}}} = conn, _) do
	user = User.get_cached_by_id(user.id)
	folder_id = Map.get(params, :folder_id)

	bookmarks =
	user.id
	\|> Bookmark.for_user_query(folder_id)
	\|> Pleroma.Pagination.fetch_paginated(params)

	activities =
	bookmarks
	\|> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)

	conn
	\|> add_link_headers(bookmarks)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	end

	@doc "GET /api/v1/statuses/:id/quotes"
	def quotes(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id} = params}}} =
	conn,
	_
	) do
	with %Activity{object: object} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:quote_url, object.data["id"])

	recipients =
	if user do
	[Pleroma.Constants.as_public()] ++ [user.ap_id \| User.following(user)]
	else
	[Pleroma.Constants.as_public()]
	end

	activities =
	recipients
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	else
	nil -> {:error, :not_found}
	false -> {:error, :not_found}
	end
	end

	defp put_application(
	params,
	%{assigns: %{token: %Token{} = token, user: %User{} = user}} = _conn
	) do
	if user.disclose_client do
	%{client_name: client_name, website: website} = Repo.preload(token, :app).app
	- Map.put(params, :generator, %{type: "Application", name: client_name, url: website})
	+
	+ Map.put(params, :generator, %{
	+ "type" => "Application",
	+ "name" => client_name,
	+ "url" => website
	+ })
	else
	Map.put(params, :generator, nil)
	end
	end

	defp put_application(params, _), do: Map.put(params, :generator, nil)
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 4625be47c..1e5e44633 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,895 +1,903 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.EmojiReactionController
	alias Pleroma.Web.RichMedia.Card

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]

	# This is a naive way to do this, just spawning a process per activity
	# to fetch the preview. However it should be fine considering
	# pagination is restricted to 40 activities at a time
	# Force disable Websockets streaming for backfill jobs,
	# otherwise old posts can show up on timelines.
	defp fetch_rich_media_for_activities(activities, opts) do
	opts = Map.put(opts, :stream, false)

	Enum.each(activities, fn activity ->
	Card.get_by_activity(activity, opts)
	end)
	end

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_quoted_activities([]), do: %{}

	defp get_quoted_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["quoteUrl"] != "" && object.data["quoteUrl"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	# DEPRECATED This field seems to be a left-over from the StatusNet era.
	# If your application uses `pleroma.conversation_id`: this field is deprecated.
	# It is currently stubbed instead by doing a CRC32 of the context, and
	# clearing the MSB to avoid overflow exceptions with signed integers on the
	# different clients using this field (Java/Kotlin code, mostly; see Husky.)
	# This should be removed in a future version of Pleroma. Pleroma-FE currently
	# depends on this field, as well.
	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
	import Bitwise

	:erlang.crc32(context)
	\|> band(bnot(0x8000_0000))
	end

	defp get_context_id(_), do: nil

	# Check if the user reblogged this status
	defp reblogged?(activity, %User{ap_id: ap_id}) do
	with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
	Object.normalize(activity, fetch: false) do
	ap_id in announcements
	else
	_ -> false
	end
	end

	# False if the user is logged out
	defp reblogged?(_activity, _user), do: false

	def render("index.json", opts) do
	reading_user = opts[:for]

	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

	# Start prefetching rich media before doing anything else
	fetch_rich_media_for_activities(activities, opts)

	replied_to_activities = get_replied_to_activities(activities)
	quoted_activities = get_quoted_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Activity.with_preloaded_bookmark(reading_user)
	\|> Activity.with_set_thread_muted_field(reading_user)
	\|> Repo.all()

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	# Note: unresolved users are filtered out
	actors =
	(activities ++ parent_activities)
	\|> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
	\|> Enum.filter(& &1)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_activities)
	\|> Map.put(:quoted_activities, quoted_activities)
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(activities, StatusView, "show.json", opts)
	end

	def render(
	"show.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	object = Object.normalize(activity, fetch: false)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	\|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()
	end

	reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
	reblogged = render("show.json", reblog_rendering_opts)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(reblogged_parent_activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: false,
	pinned: pinned?,
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: build_application(object.data["generator"]),
	language: get_language(object),
	emojis: [],
	pleroma: %{
	local: activity.local,
	pinned_at: pinned_at,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(object.data["actor"])
	user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	hashtags = Object.hashtags(object)
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	tags = Object.tags(object)

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	\|> Enum.map(fn
	Pleroma.Constants.as_public() -> nil
	^user_follower_address -> nil
	ap_id -> User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	client_posted_this_activity = opts[:for] && user.id == opts[:for].id

	expires_at =
	with true <- client_posted_this_activity,
	%Oban.Job{scheduled_at: scheduled_at} <-
	Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
	scheduled_at
	else
	_ -> nil
	end

	thread_muted? =
	cond do
	is_nil(opts[:for]) -> false
	is_boolean(activity.thread_muted?) -> activity.thread_muted?
	true -> CommonAPI.thread_muted?(activity, opts[:for])
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	edited_at =
	with %{"updated" => updated} <- object.data,
	date <- Utils.to_masto_date(updated),
	true <- date != "" do
	date
	else
	_ ->
	nil
	end

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])

	history_len =
	1 +
	(Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> length())

	# See render("history.json", ...) for more details
	# Here the implicit index of the current content is 0
	chrono_order = history_len - 1

	quote_activity = get_quote(activity, opts)

	quote_id =
	case quote_activity do
	%Activity{id: id} -> id
	_ -> nil
	end

	quote_post =
	if visible_for_user?(quote_activity, opts[:for]) and opts[:show_quote] != false do
	quote_rendering_opts = Map.merge(opts, %{activity: quote_activity, show_quote: false})
	render("show.json", quote_rendering_opts)
	else
	nil
	end

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	content_plaintext =
	content
	\|> Activity.HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	# Force disable Websockets streaming for backfill jobs which the below call will create,
	# otherwise old posts can show up on timelines.
	card =
	case Card.get_by_activity(activity, Map.put(opts, :stream, false)) do
	%Card{} = result -> render("card.json", result)
	_ -> nil
	end

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	direct_conversation_id =
	with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
	{_, true} <- {:include_id, opts[:with_direct_conversation_id]},
	{_, %User{} = for_user} <- {:for_user, opts[:for]} do
	Activity.direct_conversation_id(activity, for_user)
	else
	{:direct_conversation_id, participation_id} when is_integer(participation_id) ->
	participation_id

	_e ->
	nil
	end

	emoji_reactions =
	object
	\|> Object.get_emoji_reactions()
	\|> EmojiReactionController.filter_allowed_users(
	opts[:for],
	Map.get(opts, :with_muted, false)
	)
	\|> Stream.map(fn {emoji, users, url} ->
	build_emoji_map(emoji, users, url, opts[:for])
	end)
	\|> Enum.to_list()

	# Status muted state (would do 1 request per status unless user mutes are preloaded)
	muted =
	thread_muted? \|\|
	UserRelationship.exists?(
	get_in(opts, [:relationships, :user_relationships]),
	:mute,
	opts[:for],
	user,
	fn for_user, user -> User.mutes?(for_user, user) end
	)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	text: opts[:with_source] && get_source_text(object.data["source"]),
	created_at: created_at,
	edited_at: edited_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: muted,
	pinned: pinned?,
	sensitive: sensitive,
	spoiler_text: summary,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render(PollView, "show.json", object: object, for: opts[:for]),
	mentions: mentions,
	tags: build_tags(tags),
	application: build_application(object.data["generator"]),
	language: get_language(object),
	emojis: build_emojis(object.data["emoji"]),
	quotes_count: object.data["quotesCount"] \|\| 0,
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	context: object.data["context"],
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	quote: quote_post,
	quote_id: quote_id,
	quote_url: object.data["quoteUrl"],
	quote_visible: visible_for_user?(quote_activity, opts[:for]),
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary},
	expires_at: expires_at,
	direct_conversation_id: direct_conversation_id,
	thread_muted: thread_muted?,
	emoji_reactions: emoji_reactions,
	parent_visible: visible_for_user?(reply_to, opts[:for]),
	pinned_at: pinned_at,
	quotes_count: object.data["quotesCount"] \|\| 0,
	bookmark_folder: bookmark_folder,
	list_id: get_list_id(object, client_posted_this_activity)
	}
	}
	end

	def render("show.json", _) do
	nil
	end

	def render("history.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	hashtags = Object.hashtags(object)

	user = CommonAPI.get_user(activity.data["actor"])

	past_history =
	Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> Enum.map(&Map.put(&1, "id", object.data["id"]))
	\|> Enum.map(&%Object{data: &1, id: object.id})

	history =
	[object \| past_history]
	# Mastodon expects the original to be at the first
	\|> Enum.reverse()
	\|> Enum.with_index()
	\|> Enum.map(fn {object, chrono_order} ->
	%{
	# The history is prepended every time there is a new edit.
	# In chrono_order, the oldest item is always at 0, and so on.
	# The chrono_order is an invariant kept between edits.
	chrono_order: chrono_order,
	object: object
	}
	end)

	individual_opts =
	opts
	\|> Map.put(:as, :item)
	\|> Map.put(:user, user)
	\|> Map.put(:hashtags, hashtags)

	render_many(history, StatusView, "history_item.json", individual_opts)
	end

	def render(
	"history_item.json",
	%{
	activity: activity,
	user: user,
	item: %{object: object, chrono_order: chrono_order},
	hashtags: hashtags
	} = opts
	) do
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["updated"] \|\| object.data["published"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	%{
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	content: content_html,
	sensitive: sensitive,
	spoiler_text: summary,
	created_at: created_at,
	media_attachments: attachments,
	emojis: build_emojis(object.data["emoji"]),
	poll: render(PollView, "show.json", object: object, for: opts[:for])
	}
	end

	def render("source.json", %{activity: %{data: %{"object" => _object}} = activity} = _opts) do
	object = Object.normalize(activity, fetch: false)

	%{
	id: activity.id,
	text: get_source_text(Map.get(object.data, "source", "")),
	spoiler_text: Map.get(object.data, "summary", ""),
	content_type: get_source_content_type(object.data["source"])
	}
	end

	def render("card.json", %Card{fields: rich_media}) do
	page_url_data = URI.parse(rich_media["url"])

	page_url = page_url_data \|> to_string

	image_url = proxied_url(rich_media["image"], page_url_data)
	audio_url = proxied_url(rich_media["audio"], page_url_data)
	video_url = proxied_url(rich_media["video"], page_url_data)

	%{
	type: card_type(rich_media["type"]),
	provider_name: rich_media["provider_name"] \|\| page_url_data.host,
	provider_url:
	rich_media["provider_url"] \|\| page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url,
	image_description: rich_media["image:alt"] \|\| "",
	title: rich_media["title"] \|\| "",
	description: rich_media["description"] \|\| "",
	language: nil,
	authors: [],
	author_name: rich_media["author_name"] \|\| "",
	author_url: rich_media["author_url"] \|\| "",
	html: rich_media["html"] \|\| "",
	width: card_dimension(rich_media["width"]),
	height: card_dimension(rich_media["height"]),
	embed_url: rich_media["embed_url"] \|\| "",
	blurhash: nil,
	published_at: nil,
	pleroma: %{
	opengraph:
	rich_media
	\|> Maps.put_if_present("image", image_url)
	\|> Maps.put_if_present("audio", audio_url)
	\|> Maps.put_if_present("video", video_url)
	}
	}
	end

	def render("card.json", _), do: nil

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href_remote = attachment_url["href"]
	href = href_remote \|> MediaProxy.url()
	href_preview = attachment_url["href"] \|> MediaProxy.preview_url()
	meta = render("attachment_meta.json", %{attachment: attachment})

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	attachment_id =
	with {_, ap_id} when is_binary(ap_id) <- {:ap_id, attachment["id"]},
	{_, %Object{data: _object_data, id: object_id}} <-
	{:object, Object.get_by_ap_id(ap_id)} do
	to_string(object_id)
	else
	_ ->
	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
	to_string(attachment["id"] \|\| hash_id)
	end

	description =
	if attachment["summary"] do
	HTML.strip_tags(attachment["summary"])
	else
	attachment["name"]
	end

	name = if attachment["summary"], do: attachment["name"]

	pleroma =
	%{mime_type: media_type}
	\|> Maps.put_if_present(:name, name)

	%{
	id: attachment_id,
	url: href,
	remote_url: href_remote,
	preview_url: href_preview,
	text_url: href,
	type: type,
	description: description,
	pleroma: pleroma,
	blurhash: attachment["blurhash"]
	}
	\|> Maps.put_if_present(:meta, meta)
	end

	def render("attachment_meta.json", %{
	attachment: %{"url" => [%{"width" => width, "height" => height} \| _]}
	})
	when is_integer(width) and is_integer(height) do
	%{
	original: %{
	width: width,
	height: height,
	aspect: width / height
	}
	}
	end

	def render("attachment_meta.json", _), do: nil

	def render("context.json", %{activity: activity, activities: activities, user: user}) do
	%{ancestors: ancestors, descendants: descendants} =
	activities
	\|> Enum.reverse()
	- \|> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
	+ \|> Enum.group_by(fn %{id: id} ->
	+ if id < activity.id, do: :ancestors, else: :descendants
	+ end)
	\|> Map.put_new(:ancestors, [])
	\|> Map.put_new(:descendants, [])

	%{
	ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
	descendants: render("index.json", for: user, activities: descendants, as: :activity)
	}
	end

	def render("translation.json", %{
	content: content,
	detected_source_language: detected_source_language,
	provider: provider
	}) do
	%{content: content, detected_source_language: detected_source_language, provider: provider}
	end

	defp card_type(type) when type in ["link", "photo", "video", "rich"], do: type
	defp card_type(_), do: "link"

	defp card_dimension(value) when is_integer(value) and value >= 0, do: value

	defp card_dimension(value) when is_binary(value) do
	case Integer.parse(value) do
	{dimension, ""} when dimension >= 0 -> dimension
	_ -> 0
	end
	end

	defp card_dimension(_), do: 0

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def get_quote(activity, %{quoted_activities: quoted_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- quoted_activities[object.data["quoteUrl"]] do
	# For when a quote post is inside an Announce
	Activity.get_create_by_object_ap_id_with_object(object.data["quoteUrl"])
	end
	end

	def get_quote(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["quoteUrl"] && object.data["quoteUrl"] != "" do
	Activity.get_create_by_object_ap_id(object.data["quoteUrl"])
	else
	nil
	end
	end

	def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
	url = object.data["url"] \|\| object.data["id"]

	"<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags
	- \|> Enum.filter(&is_binary/1)
	+ \|> Enum.map(fn
	+ tag when is_binary(tag) -> tag
	+ %{"type" => "Hashtag", "name" => "#" <> name} -> name
	+ _ -> nil
	+ end)
	+ \|> Enum.reject(&is_nil/1)
	+ \|> Enum.uniq()
	\|> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
	if pinned_at = pinned_objects[object_id] do
	{true, Utils.to_masto_date(pinned_at)}
	else
	{false, nil}
	end
	end

	defp build_emoji_map(emoji, users, url, current_user) do
	%{
	name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
	count: length(users),
	url: MediaProxy.url(url),
	me: !!(current_user && current_user.ap_id in users),
	account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	defp build_application(%{"type" => _type, "name" => name, "url" => url}),
	do: %{name: name, website: url}

	defp build_application(_), do: nil

	@spec build_image_url(URI.t(), URI.t()) :: String.t()
	defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
	URI.merge(page_url_data, image_url_data) \|> to_string
	end

	defp get_source_text(%{"content" => content} = _source) do
	content
	end

	defp get_source_text(source) when is_binary(source) do
	source
	end

	defp get_source_text(_) do
	""
	end

	defp get_source_content_type(%{"mediaType" => type} = _source) do
	type
	end

	defp get_source_content_type(_source) do
	Utils.get_content_type(nil)
	end

	defp get_language(%{data: %{"language" => "und"}}), do: nil

	defp get_language(object), do: object.data["language"]

	defp proxied_url(url, page_url_data) do
	if is_binary(url) do
	build_image_url(URI.parse(url), page_url_data) \|> MediaProxy.url()
	else
	nil
	end
	end

	defp get_list_id(object, client_posted_this_activity) do
	with true <- client_posted_this_activity,
	%{data: %{"listMessage" => list_ap_id}} when is_binary(list_ap_id) <- object,
	%{id: list_id} <- Pleroma.List.get_by_ap_id(list_ap_id) do
	list_id
	else
	_ -> nil
	end
	end
	end
	diff --git a/test/mix/tasks/pleroma/database_test.exs b/test/mix/tasks/pleroma/database_test.exs
	index 0f38891b4..a80467525 100644
	--- a/test/mix/tasks/pleroma/database_test.exs
	+++ b/test/mix/tasks/pleroma/database_test.exs
	@@ -1,695 +1,695 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.DatabaseTest do
	use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Hashtag
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup_all do
	Mix.shell(Mix.Shell.Process)

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

	:ok
	end

	describe "running remove_embedded_objects" do
	test "it replaces objects with references" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "test"})
	new_data = Map.put(activity.data, "object", activity.object.data)

	{:ok, activity} =
	activity
	\|> Activity.change(%{data: new_data})
	\|> Repo.update()

	assert is_map(activity.data["object"])

	Mix.Tasks.Pleroma.Database.run(["remove_embedded_objects"])

	activity = Activity.get_by_id_with_object(activity.id)
	assert is_binary(activity.data["object"])
	end
	end

	describe "prune_objects" do
	setup do
	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days]) + 1

	old_insert_date =
	Timex.now()
	\|> Timex.shift(days: -deadline)
	\|> Timex.to_naive_datetime()
	\|> NaiveDateTime.truncate(:second)

	%{old_insert_date: old_insert_date}
	end

	test "it prunes old objects from the database", %{old_insert_date: old_insert_date} do
	insert(:note)

	%{id: note_remote_public_id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	note_remote_non_public =
	%{id: note_remote_non_public_id, data: note_remote_non_public_data} =
	:note
	\|> insert()

	note_remote_non_public
	\|> Ecto.Changeset.change(%{
	updated_at: old_insert_date,
	data: note_remote_non_public_data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	refute Object.get_by_id(note_remote_public_id)
	refute Object.get_by_id(note_remote_non_public_id)
	end

	test "it cleans up bookmarks", %{old_insert_date: old_insert_date} do
	user = insert(:user)
	{:ok, old_object_activity} = CommonAPI.post(user, %{status: "yadayada"})

	Repo.one(Object)
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, new_object_activity} = CommonAPI.post(user, %{status: "yadayada"})

	{:ok, _} = Bookmark.create(user.id, old_object_activity.id)
	{:ok, _} = Bookmark.create(user.id, new_object_activity.id)

	assert length(Repo.all(Object)) == 2
	assert length(Repo.all(Bookmark)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	assert length(Repo.all(Bookmark)) == 1
	refute Bookmark.get(user.id, old_object_activity.id)
	end

	test "with the --keep-non-public option it still keeps non-public posts even if they are not local",
	%{old_insert_date: old_insert_date} do
	insert(:note)

	%{id: note_remote_id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	note_remote_non_public =
	%{data: note_remote_non_public_data} =
	:note
	\|> insert()

	note_remote_non_public
	\|> Ecto.Changeset.change(%{
	updated_at: old_insert_date,
	data: note_remote_non_public_data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-non-public"])

	assert length(Repo.all(Object)) == 2
	refute Object.get_by_id(note_remote_id)
	end

	test "with the --keep-threads and --keep-non-public option it keeps old threads with non-public replies even if the interaction is not local",
	%{old_insert_date: old_insert_date} do
	# For non-public we only check Create Activities because only these are relevant for threads
	# Flags are always non-public, Announces from relays can be non-public...

	remote_user1 = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	# Old remote non-public reply (should be kept)
	{:ok, old_remote_post1_activity} =
	- CommonAPI.post(remote_user1, %{status: "some thing", local: false})
	+ post_as_remote(remote_user1, %{status: "some thing", local: false})

	old_remote_post1_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_non_public_reply_activity} =
	- CommonAPI.post(remote_user2, %{
	+ post_as_remote(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post1_activity.id
	})

	old_remote_non_public_reply_activity
	\|> Ecto.Changeset.change(%{
	local: false,
	updated_at: old_insert_date,
	data: old_remote_non_public_reply_activity.data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	# Old remote non-public Announce (should be removed)
	{:ok, old_remote_post2_activity = %{data: %{"object" => old_remote_post2_id}}} =
	- CommonAPI.post(remote_user1, %{status: "some thing", local: false})
	+ post_as_remote(remote_user1, %{status: "some thing", local: false})

	old_remote_post2_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_non_public_repeat_activity} =
	CommonAPI.repeat(old_remote_post2_activity.id, remote_user2)

	old_remote_non_public_repeat_activity
	\|> Ecto.Changeset.change(%{
	local: false,
	updated_at: old_insert_date,
	data: old_remote_non_public_repeat_activity.data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads", "--keep-non-public"])

	Repo.all(Pleroma.Activity)
	assert length(Repo.all(Object)) == 2
	refute Object.get_by_ap_id(old_remote_post2_id)
	end

	test "with the --keep-threads option it still keeps non-old threads even with no local interactions" do
	remote_user = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	{:ok, remote_post_activity} =
	- CommonAPI.post(remote_user, %{status: "some thing", local: false})
	+ post_as_remote(remote_user, %{status: "some thing", local: false})

	{:ok, remote_post_reply_activity} =
	- CommonAPI.post(remote_user2, %{
	+ post_as_remote(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: remote_post_activity.id
	})

	remote_post_activity
	\|> Ecto.Changeset.change(%{local: false})
	\|> Repo.update!()

	remote_post_reply_activity
	\|> Ecto.Changeset.change(%{local: false})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 2
	end

	test "with the --keep-threads option it deletes old threads with no local interaction", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	{:ok, old_remote_post_activity} =
	- CommonAPI.post(remote_user, %{status: "some thing", local: false})
	+ post_as_remote(remote_user, %{status: "some thing", local: false})

	old_remote_post_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_post_reply_activity} =
	- CommonAPI.post(remote_user2, %{
	+ post_as_remote(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post_activity.id
	})

	old_remote_post_reply_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_favourite_activity} =
	CommonAPI.favorite(old_remote_post_activity.id, remote_user2)

	old_favourite_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_repeat_activity} = CommonAPI.repeat(old_remote_post_activity.id, remote_user2)

	old_repeat_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 0
	end

	test "with the --keep-threads option it keeps old threads with local interaction", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	local_user = insert(:user, local: true)

	# local reply
	{:ok, old_remote_post1_activity} =
	- CommonAPI.post(remote_user, %{status: "some thing", local: false})
	+ post_as_remote(remote_user, %{status: "some thing", local: false})

	old_remote_post1_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_local_post2_reply_activity} =
	CommonAPI.post(local_user, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post1_activity.id
	})

	old_local_post2_reply_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	# local Like
	{:ok, old_remote_post3_activity} =
	- CommonAPI.post(remote_user, %{status: "some thing", local: false})
	+ post_as_remote(remote_user, %{status: "some thing", local: false})

	old_remote_post3_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_favourite_activity} = CommonAPI.favorite(old_remote_post3_activity.id, local_user)

	old_favourite_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	# local Announce
	{:ok, old_remote_post4_activity} =
	- CommonAPI.post(remote_user, %{status: "some thing", local: false})
	+ post_as_remote(remote_user, %{status: "some thing", local: false})

	old_remote_post4_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_repeat_activity} = CommonAPI.repeat(old_remote_post4_activity.id, local_user)

	old_repeat_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 4

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 4
	end

	test "with the --keep-threads option it keeps old threads with bookmarked posts", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	local_user = insert(:user, local: true)

	{:ok, old_remote_post_activity} =
	- CommonAPI.post(remote_user, %{status: "some thing", local: false})
	+ post_as_remote(remote_user, %{status: "some thing", local: false})

	old_remote_post_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	Pleroma.Bookmark.create(local_user.id, old_remote_post_activity.id)

	assert length(Repo.all(Object)) == 1

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 1
	end

	test "We don't have unexpected tables which may contain objects that are referenced by activities" do
	# We can delete orphaned activities. For that we look for the objects
	# they reference in the 'objects', 'activities', and 'users' table.
	# If someone adds another table with objects (idk, maybe with separate
	# relations, or collections or w/e), then we need to make sure we
	# add logic for that in the 'prune_objects' task so that we don't
	# wrongly delete their corresponding activities.
	# So when someone adds (or removes) a table, this test will fail.
	# Either the table contains objects which can be referenced from the
	# activities table
	# => in that case the prune_objects job should be adapted so we don't
	# delete activities who still have the referenced object.
	# Or it doesn't contain objects which can be referenced from the activities table
	# => in that case you can add/remove the table to/from this (sorted) list.

	assert Repo.query!(
	"SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';"
	).rows
	\|> Enum.sort() == [
	["activities"],
	["announcement_read_relationships"],
	["announcements"],
	["apps"],
	["backups"],
	["bookmark_folders"],
	["bookmarks"],
	["chat_message_references"],
	["chats"],
	["config"],
	["conversation_participation_recipient_ships"],
	["conversation_participations"],
	["conversations"],
	["counter_cache"],
	["data_migration_failed_ids"],
	["data_migrations"],
	["deliveries"],
	["filters"],
	["following_relationships"],
	["hashtags"],
	["hashtags_objects"],
	["instances"],
	["lists"],
	["markers"],
	["mfa_tokens"],
	["moderation_log"],
	["notifications"],
	["oauth_authorizations"],
	["oauth_tokens"],
	["oban_jobs"],
	["oban_peers"],
	["objects"],
	["password_reset_tokens"],
	["push_subscriptions"],
	["registrations"],
	["report_notes"],
	["rich_media_card"],
	["rules"],
	["scheduled_activities"],
	["schema_migrations"],
	["thread_mutes"],
	["user_follows_hashtag"],
	# ["user_frontend_setting_profiles"], # not in pleroma
	["user_invite_tokens"],
	["user_notes"],
	["user_relationships"],
	["users"],
	["webhooks"]
	]
	end

	test "it prunes orphaned activities with the --prune-orphaned-activities" do
	# Add a remote activity which references an Object
	%Object{} \|> Map.merge(%{data: %{"id" => "object_for_activity"}}) \|> Repo.insert()

	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{"id" => "remote_activity_with_object", "object" => "object_for_activity"}
	})
	\|> Repo.insert()

	# Add a remote activity which references an activity
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_with_activity",
	"object" => "remote_activity_with_object"
	}
	})
	\|> Repo.insert()

	# Add a remote activity which references an Actor
	%User{} \|> Map.merge(%{ap_id: "actor"}) \|> Repo.insert()

	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{"id" => "remote_activity_with_actor", "object" => "actor"}
	})
	\|> Repo.insert()

	# Add a remote activity without existing referenced object, activity or actor
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_without_existing_referenced_object",
	"object" => "non_existing"
	}
	})
	\|> Repo.insert()

	# Add a local activity without existing referenced object, activity or actor
	%Activity{}
	\|> Map.merge(%{
	local: true,
	data: %{"id" => "local_activity_with_actor", "object" => "non_existing"}
	})
	\|> Repo.insert()

	# The remote activities without existing reference,
	# and only the remote activities without existing reference, are deleted
	# if, and only if, we provide the --prune-orphaned-activities option
	assert length(Repo.all(Activity)) == 5
	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Activity)) == 5
	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--prune-orphaned-activities"])
	activities = Repo.all(Activity)

	assert "remote_activity_without_existing_referenced_object" not in Enum.map(
	activities,
	fn a -> a.data["id"] end
	)

	assert length(activities) == 4
	end

	test "it prunes orphaned activities with the --prune-orphaned-activities when the objects are referenced from an array" do
	%Object{} \|> Map.merge(%{data: %{"id" => "existing_object"}}) \|> Repo.insert()
	%User{} \|> Map.merge(%{ap_id: "existing_actor"}) \|> Repo.insert()

	# Multiple objects, one object exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_object",
	"object" => ["non_ existing_object", "existing_object"]
	}
	})
	\|> Repo.insert()

	# Multiple objects, one actor exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_actor",
	"object" => ["non_ existing_object", "existing_actor"]
	}
	})
	\|> Repo.insert()

	# Multiple objects, one activity exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_activity",
	"object" => ["non_ existing_object", "remote_activity_existing_actor"]
	}
	})
	\|> Repo.insert()

	# Multiple objects none exist (prune)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_without_existing_referenced_object",
	"object" => ["owo", "whats_this"]
	}
	})
	\|> Repo.insert()

	assert length(Repo.all(Activity)) == 4
	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Activity)) == 4
	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--prune-orphaned-activities"])
	activities = Repo.all(Activity)
	assert length(activities) == 3

	assert "remote_activity_without_existing_referenced_object" not in Enum.map(
	activities,
	fn a -> a.data["id"] end
	)

	assert length(activities) == 3
	end

	test "it prunes hashtags with no objects associated", %{old_insert_date: old_insert_date} do
	user = insert(:user)

	{:ok, hashtag_post_activity} =
	CommonAPI.post(user, %{status: "morning #cofe", local: true})

	hashtag_post_object = Object.normalize(hashtag_post_activity)

	{:ok, hashtag_post2_activity} =
	CommonAPI.post(user, %{status: "morning #cawfee", local: true})

	hashtag_post2_object = Object.normalize(hashtag_post2_activity)

	hashtag_post_object
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	hashtag_post2_object
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	# Test whether hashtags with follow relationships are kept
	User.follow_hashtag(user, Hashtag.get_by_name("cofe"))

	assert length(Repo.all(Hashtag)) == 2
	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Hashtag)) == 1
	assert length(Repo.all(Object)) == 0
	assert Repo.one(Hashtag) \|> Map.fetch!(:name) == "cofe"
	end
	end

	describe "running update_users_following_followers_counts" do
	test "following and followers count are updated" do
	[user, user2] = insert_pair(:user)
	{:ok, %User{} = user, _user2} = User.follow(user, user2)

	following = User.following(user)

	assert length(following) == 2
	assert user.follower_count == 0

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{follower_count: 3})
	\|> Repo.update()

	assert user.follower_count == 3

	assert {:ok, :ok} ==
	Mix.Tasks.Pleroma.Database.run(["update_users_following_followers_counts"])

	user = User.get_by_id(user.id)

	assert length(User.following(user)) == 2
	assert user.follower_count == 0
	end
	end

	describe "running fix_likes_collections" do
	test "it turns OrderedCollection likes into empty arrays" do
	[user, user2] = insert_pair(:user)

	{:ok, %{id: id, object: object}} = CommonAPI.post(user, %{status: "test"})
	{:ok, %{object: object2}} = CommonAPI.post(user, %{status: "test test"})

	CommonAPI.favorite(id, user2)

	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"
	}

	new_data = Map.put(object2.data, "likes", likes)

	object2
	\|> Ecto.Changeset.change(%{data: new_data})
	\|> Repo.update()

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert is_map(Object.get_by_id(object2.id).data["likes"])

	assert :ok == Mix.Tasks.Pleroma.Database.run(["fix_likes_collections"])

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert Enum.empty?(Object.get_by_id(object2.id).data["likes"])
	end
	end

	describe "ensure_expiration" do
	test "it adds to expiration old statuses" do
	activity1 = insert(:note_activity)

	{:ok, inserted_at, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
	activity2 = insert(:note_activity, %{inserted_at: inserted_at})

	%{id: activity_id3} = insert(:note_activity)

	expires_at = DateTime.add(DateTime.utc_now(), 60 * 61)

	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: activity_id3
	},
	scheduled_at: expires_at
	)

	Mix.Tasks.Pleroma.Database.run(["ensure_expiration"])

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity1.id},
	scheduled_at:
	activity1.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity2.id},
	scheduled_at:
	activity2.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity_id3},
	scheduled_at: expires_at
	)
	end
	end
	end
	diff --git a/test/pleroma/conversation_test.exs b/test/pleroma/conversation_test.exs
	index bc41165ed..555aca452 100644
	--- a/test/pleroma/conversation_test.exs
	+++ b/test/pleroma/conversation_test.exs
	@@ -1,208 +1,208 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConversationTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Conversation
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

	test "it goes through old direct conversations" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{visibility: "direct", status: "hey @#{other_user.nickname}"})

	Pleroma.Tests.ObanHelpers.perform_all()

	Repo.delete_all(Conversation)
	Repo.delete_all(Conversation.Participation)

	refute Repo.one(Conversation)

	Conversation.bump_for_all_activities()

	assert Repo.one(Conversation)
	[participation, _p2] = Repo.all(Conversation.Participation)

	assert participation.read
	end

	test "it creates a conversation for given ap_id" do
	assert {:ok, %Conversation{} = conversation} =
	Conversation.create_for_ap_id("https://some_ap_id")

	# Inserting again returns the same
	assert {:ok, conversation_two} = Conversation.create_for_ap_id("https://some_ap_id")
	assert conversation_two.id == conversation.id
	end

	test "public posts don't create conversations" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "Hey"})

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

	conversation = Conversation.get_for_ap_id(context)

	refute conversation
	end

	test "it creates or updates a conversation and participations for a given DM" do
	har = insert(:user)
	jafnhar = insert(:user, local: false)
	tridi = insert(:user)

	to = [har.nickname, jafnhar.nickname, tridi.nickname]

	{:ok, activity} =
	CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct", to: to})

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

	conversation =
	Conversation.get_for_ap_id(context)
	\|> Repo.preload(:participations)

	assert conversation

	assert Enum.find(conversation.participations, fn %{user_id: user_id} -> har.id == user_id end)

	assert Enum.find(conversation.participations, fn %{user_id: user_id} ->
	jafnhar.id == user_id
	end)

	{:ok, activity} =
	- CommonAPI.post(jafnhar, %{
	+ post_as_remote(jafnhar, %{
	status: "Hey @#{har.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	to: to
	})

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

	conversation_two =
	Conversation.get_for_ap_id(context)
	\|> Repo.preload(:participations)

	assert conversation_two.id == conversation.id

	assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
	har.id == user_id
	end)

	assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
	jafnhar.id == user_id
	end)

	{:ok, activity} =
	CommonAPI.post(tridi, %{
	status: "Hey @#{har.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	to: to
	})

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

	conversation_three =
	Conversation.get_for_ap_id(context)
	\|> Repo.preload([:participations, :users])

	assert conversation_three.id == conversation.id

	assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
	har.id == user_id
	end)

	assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
	jafnhar.id == user_id
	end)

	assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
	tridi.id == user_id
	end)

	assert Enum.find(conversation_three.users, fn %{id: user_id} ->
	har.id == user_id
	end)

	assert Enum.find(conversation_three.users, fn %{id: user_id} ->
	jafnhar.id == user_id
	end)

	assert Enum.find(conversation_three.users, fn %{id: user_id} ->
	tridi.id == user_id
	end)
	end

	test "create_or_bump_for returns the conversation with participations" do
	har = insert(:user)
	jafnhar = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})

	{:ok, conversation} = Conversation.create_or_bump_for(activity)

	assert length(conversation.participations) == 2

	{:ok, activity} =
	CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "public"})

	assert {:error, _} = Conversation.create_or_bump_for(activity)
	end

	test "create_or_bump_for does not normalize objects before checking the activity type" do
	note = insert(:note)
	note_id = note.data["id"]
	Repo.delete(note)
	refute Object.get_by_ap_id(note_id)

	Tesla.Mock.mock(fn env ->
	case env.url do
	^note_id ->
	# TODO: add attributedTo and tag to the note factory
	body =
	note.data
	\|> Map.put("attributedTo", note.data["actor"])
	\|> Map.put("tag", [])
	\|> Jason.encode!()

	%Tesla.Env{status: 200, body: body}
	end
	end)

	undo = %Activity{
	id: "fake",
	data: %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => note.data["actor"],
	"to" => [note.data["actor"]],
	"object" => note_id,
	"type" => "Undo"
	}
	}

	Conversation.create_or_bump_for(undo)

	refute Object.get_by_ap_id(note_id)
	end
	end
	diff --git a/test/pleroma/notification_test.exs b/test/pleroma/notification_test.exs
	index 992b15f8b..f0a5b7b76 100644
	--- a/test/pleroma/notification_test.exs
	+++ b/test/pleroma/notification_test.exs
	@@ -1,1171 +1,1171 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase, async: false

	import Pleroma.Factory

	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.Streamer

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

	describe "create_notifications" do
	test "never returns nil" do
	user = insert(:user)
	other_user = insert(:user, %{invisible: true})

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	refute {:ok, [nil]} == Notification.create_notifications(activity)
	end

	test "creates a report notification only for privileged users" do
	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	clear_config([:instance, :moderator_privileges], [])
	{:ok, activity1} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, []} = Notification.create_notifications(activity1)

	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])
	{:ok, activity2} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity2)

	assert notification.user_id == moderator_user.id
	assert notification.type == "pleroma:report"
	end

	test "suppresses notifications for own reports" do
	clear_config([:instance, :admin_privileges], [:reports_manage_reports])

	reporting_admin = insert(:user, is_admin: true)
	reported_user = insert(:user)
	other_admin = insert(:user, is_admin: true)

	{:ok, activity} = CommonAPI.report(reporting_admin, %{account_id: reported_user.id})

	{:ok, [notification]} = Notification.create_notifications(activity)

	refute notification.user_id == reporting_admin.id
	assert notification.user_id == other_admin.id
	assert notification.type == "pleroma:report"
	end

	test "creates a notification for an emoji reaction" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	{:ok, [notification]} = Notification.create_notifications(activity)

	assert notification.user_id == user.id
	assert notification.type == "pleroma:emoji_reaction"
	end

	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname} and @#{third_user.nickname}"
	})

	{:ok, [notification, other_notification]} = Notification.create_notifications(activity)

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert notification.type == "mention"
	assert other_notification.activity_id == activity.id

	assert [%Pleroma.Marker{unread_count: 2}] =
	Pleroma.Marker.get_markers(other_user, ["notifications"])
	end

	test "it creates a notification for subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification.user_id == subscriber.id
	assert notification.type == "status"
	end

	test "does not create a notification for subscribed users if status is a reply" do
	user = insert(:user)
	other_user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, other_user)

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

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	status: "test reply",
	in_reply_to_status_id: activity.id
	})

	user_notifications = Notification.for_user(user)
	assert length(user_notifications) == 1

	subscriber_notifications = Notification.for_user(subscriber)
	assert Enum.empty?(subscriber_notifications)
	end

	test "does not create subscriber notification if mentioned" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "mentioning @#{subscriber.nickname}"})
	{:ok, [notification] = notifications} = Notification.create_notifications(status)

	assert length(notifications) == 1

	assert notification.user_id == subscriber.id
	assert notification.type == "mention"
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

	{:ok, _edit_activity} =
	CommonAPI.update(activity_one, user, %{
	status: "hey @#{other_user.nickname}! mew mew"
	})

	assert [%{type: "reblog"}] = Notification.for_user(user)
	assert [%{type: "update"}] = Notification.for_user(repeated_user)
	assert [%{type: "mention"}] = Notification.for_user(other_user)
	end
	end

	test "create_poll_notifications/1" do
	[user1, user2, user3, _, _] = insert_list(5, :user)
	question = insert(:question, user: user1)
	activity = insert(:question_activity, question: question)

	{:ok, _, _} = CommonAPI.vote(question, user2, [0])
	{:ok, _, _} = CommonAPI.vote(question, user3, [1])

	{:ok, notifications} = Notification.create_poll_notifications(activity)

	assert [user2.id, user3.id, user1.id] == Enum.map(notifications, & &1.user_id)
	end

	describe "create_notification" do
	test "it disables notifications from strangers" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from non-followees" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(followed, follower)
	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it allows notifications from followees" do
	poster = insert(:user)

	receiver =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(poster, receiver)
	{:ok, activity} = CommonAPI.post(poster, %{status: "hey @#{receiver.nickname}"})
	assert Notification.create_notification(activity, receiver)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	refute Notification.create_notification(activity, author)
	end

	test "it doesn't create duplicate notifications for follow+subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, subscriber)
	User.subscribe(subscriber, user)
	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [_notif]} = Notification.create_notifications(status)
	end

	test "it doesn't create subscription notifications if the recipient cannot see the status" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it disables notifications from people who are invisible" do
	author = insert(:user, invisible: true)
	user = insert(:user)

	{:ok, status} = CommonAPI.post(author, %{status: "hey @#{user.nickname}"})
	refute Notification.create_notification(status, user)
	end

	test "it doesn't create notifications if content matches with an irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: true)

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

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it creates notifications if content matches with a not irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: false)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification
	refute notification.seen
	end

	test "it creates notifications when someone likes user's status with a filtered word" do
	user = insert(:user)
	other_user = insert(:user)
	insert(:filter, user: user, phrase: "tesla", hide: true)

	{:ok, activity_one} = CommonAPI.post(user, %{status: "wow tesla"})
	{:ok, activity_two} = CommonAPI.favorite(activity_one.id, other_user)

	{:ok, [notification]} = Notification.create_notifications(activity_two)

	assert notification
	refute notification.seen
	end
	end

	describe "follow / follow_request notifications" do
	test "it creates `follow` notification for approved Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end

	test "it creates `follow_request` notification for pending Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: true)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	render_opts = %{notification: notification, for: followed_user}
	assert %{type: "follow_request"} = NotificationView.render("show.json", render_opts)

	# After request is accepted, the same notification is rendered with type "follow":
	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	notification =
	Repo.get(Notification, notification.id)
	\|> Repo.preload(:activity)

	assert %{type: "follow"} =
	NotificationView.render("show.json",
	notification: notification,
	for: followed_user
	)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	CommonAPI.unfollow(followed_user, user)
	{:ok, _, _, _activity_dupe} = CommonAPI.follow(followed_user, user)

	notification_id = notification.id
	assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
	end

	test "dismisses the notification on follow request rejection" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	{:ok, _, _, _follow_activity} = CommonAPI.follow(user, follower)
	assert [_notification] = Notification.for_user(user)
	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
	assert [] = Notification.for_user(user)
	end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.get(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.dismiss(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	[user, other_user] = insert_pair(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = Notification.for_user(other_user)

	assert n2.id > n1.id

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey yet again @#{other_user.nickname}!"
	})

	Notification.set_read_up_to(other_user, n2.id)

	[n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false

	assert %Pleroma.Marker{} =
	m =
	Pleroma.Repo.get_by(
	Pleroma.Marker,
	user_id: other_user.id,
	timeline: "notifications"
	)

	assert m.last_read_id == to_string(n2.id)
	end

	@tag needs_streamer: true
	test "it sends updated marker to the 'user' and the 'user:notification' stream" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(other_user, %{
	status: "hi @#{user.nickname}!"
	})

	[%{id: notification_id}] = Notification.for_user(user)

	notification_id = to_string(notification_id)

	task =
	Task.async(fn ->
	{:ok, _topic} =
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	assert_receive {:text, event}, 4_000

	assert %{"event" => "marker", "payload" => payload} = Jason.decode!(event)

	assert %{"notifications" => %{"last_read_id" => ^notification_id}} =
	Jason.decode!(payload)
	end)

	Notification.set_read_up_to(user, notification_id)
	Task.await(task)
	end
	end

	describe "for_user_since/2" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Returns recent notifications" do
	user1 = insert(:user)
	user2 = insert(:user)

	Enum.each(0..10, fn i ->
	{:ok, _activity} =
	CommonAPI.post(user1, %{
	status: "hey ##{i} @#{user2.nickname}!"
	})
	end)

	{old, new} = Enum.split(Notification.for_user(user2), 5)

	Enum.each(old, fn notification ->
	notification
	\|> cast(%{updated_at: days_ago(10)}, [:updated_at])
	\|> Pleroma.Repo.update!()
	end)

	recent_notifications_ids =
	user2
	\|> Notification.for_user_since(
	NaiveDateTime.add(NaiveDateTime.utc_now(), -5 * 86_400, :second)
	)
	\|> Enum.map(& &1.id)

	Enum.each(old, fn %{id: id} ->
	refute id in recent_notifications_ids
	end)

	Enum.each(new, fn %{id: id} ->
	assert id in recent_notifications_ids
	end)
	end
	end

	describe "notification target determination / get_notified_from_activity/2" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user not in enabled_receivers
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two} = CommonAPI.favorite(activity_one.id, third_user)

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it only notifies the post's author in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, like_data, _} = Builder.like(third_user, activity_one.object)

	{:ok, like, _} =
	like_data
	\|> Map.put("to", [other_user.ap_id \| like_data["to"]])
	\|> ActivityPub.persist(local: true)

	enabled_receivers = Notification.get_notified_from_activity(like)

	assert other_user not in enabled_receivers
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two} = CommonAPI.repeat(activity_one.id, third_user)

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it does not return blocking recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(other_user, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return notification-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationships} = User.mute(other_user, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return thread-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	{:ok, _} = CommonAPI.add_mute(activity, other_user)

	{:ok, same_context_activity} =
	CommonAPI.post(user, %{
	status: "hey-hey-hey @#{other_user.nickname}!",
	in_reply_to_status_id: activity.id
	})

	enabled_receivers = Notification.get_notified_from_activity(same_context_activity)

	refute other_user in enabled_receivers
	end

	test "it does not return non-following domain-blocking recipient in recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)

	- {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
	+ {:ok, activity} = post_as_remote(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it returns following domain-blocking recipient in enabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)
	{:ok, other_user, user} = User.follow(other_user, user)

	- {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
	+ {:ok, activity} = post_as_remote(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [other_user] == enabled_receivers
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

	{:ok, edit_activity} =
	CommonAPI.update(activity_one, user, %{
	status: "hey @#{other_user.nickname}! mew mew"
	})

	enabled_receivers = Notification.get_notified_from_activity(edit_activity)

	assert repeated_user in enabled_receivers
	refute other_user in enabled_receivers
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.unfavorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.unrepeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, :not_found} = CommonAPI.favorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "notifications are deleted if a local user is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})

	refute Enum.empty?(Notification.for_user(other_user))

	{:ok, job} = User.delete(user)
	ObanHelpers.perform(job)

	assert Enum.empty?(Notification.for_user(other_user))
	end

	test "notifications are deleted if a remote user is deleted" do
	remote_user = insert(:user)
	local_user = insert(:user)

	dm_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => remote_user.ap_id,
	"id" => remote_user.ap_id <> "/activities/test",
	"to" => [local_user.ap_id],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => remote_user.ap_id <> "/objects/test",
	"content" => "Hello!",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => local_user.ap_id,
	"name" => "@#{local_user.nickname}"
	}
	],
	"to" => [local_user.ap_id],
	"cc" => [],
	"attributedTo" => remote_user.ap_id
	}
	}

	{:ok, _dm_activity} = Transmogrifier.handle_incoming(dm_message)

	refute Enum.empty?(Notification.for_user(local_user))

	delete_user_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => remote_user.ap_id <> "/activities/delete",
	"actor" => remote_user.ap_id,
	"type" => "Delete",
	"object" => remote_user.ap_id
	}

	remote_user_url = remote_user.ap_id

	Tesla.Mock.mock(fn
	%{method: :get, url: ^remote_user_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	{:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
	ObanHelpers.perform_all()

	assert Enum.empty?(Notification.for_user(local_user))
	end

	test "move activity generates a notification" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	other_follower = insert(:user, %{allow_following_move: false})

	User.follow(follower, old_user)
	User.follow(other_follower, old_user)

	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	ObanHelpers.perform_all()

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(follower)

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(other_follower)
	end
	end

	describe "for_user" do
	setup do
	user = insert(:user)

	{:ok, %{user: user}}
	end

	test "it returns notifications for muted user without notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted, %{notifications: false})

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	[notification] = Notification.for_user(user)

	assert notification.activity.object
	assert notification.seen
	end

	test "it doesn't return notifications for muted user with notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for blocked user", %{user: user} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications from a blocked domain unless the actor is followed",
	%{user: user} do
	blocked_domain = "blocked.example"
	stranger = insert(:user, local: false, domain: blocked_domain)
	followed = insert(:user, local: false, domain: blocked_domain)
	{:ok, user, followed} = User.follow(user, followed)
	{:ok, user} = User.block_domain(user, blocked_domain)

	- {:ok, _} = CommonAPI.post(stranger, %{status: "hey @#{user.nickname}"})
	- {:ok, followed_activity} = CommonAPI.post(followed, %{status: "hey @#{user.nickname}"})
	+ {:ok, _} = post_as_remote(stranger, %{status: "hey @#{user.nickname}"})
	+ {:ok, followed_activity} = post_as_remote(followed, %{status: "hey @#{user.nickname}"})

	assert [%{activity: %{id: followed_id}}] = Notification.for_user(user)
	assert followed_id == followed_activity.id
	end

	test "it doesn't return notifications for domain-blocked non-followed user", %{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	- {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
	+ {:ok, _activity} = post_as_remote(blocked, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it returns notifications for domain-blocked but followed user" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")

	{:ok, user} = User.block_domain(user, "some-domain.com")
	{:ok, _, _} = User.follow(user, blocked)

	- {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
	+ {:ok, _activity} = post_as_remote(blocked, %{status: "hey @#{user.nickname}"})

	assert length(Notification.for_user(user)) == 1
	end

	test "it doesn't return notifications for muted thread", %{user: user} do
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications from a muted user when with_muted is set", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it doesn't return notifications from a blocked user when with_muted is set", %{
	user: user
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "when with_muted is set, " <>
	"it doesn't return notifications from a domain-blocked non-followed user",
	%{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	- {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
	+ {:ok, _activity} = post_as_remote(blocked, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it returns notifications from muted threads when with_muted is set", %{user: user} do
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications about mentions with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(another_user, %{status: "@#{user.nickname} got cofe?"})

	assert Enum.empty?(Notification.for_user(user))
	end

	test "it returns notifications about mentions with not hidden filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "test", hide: false)
	another_user = insert(:user)

	{:ok, _} = CommonAPI.post(another_user, %{status: "@#{user.nickname} test"})

	assert length(Notification.for_user(user)) == 1
	end

	test "it returns notifications about favorites with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Give me my cofe!"})
	{:ok, _} = CommonAPI.favorite(activity.id, another_user)

	assert length(Notification.for_user(user)) == 1
	end

	test "it returns notifications when related object is without content and filters are defined",
	%{user: user} do
	followed_user = insert(:user, is_locked: true)

	insert(:filter, user: followed_user, phrase: "test", hide: true)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow_request"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})

	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end
	end
	end
	diff --git a/test/pleroma/stats_test.exs b/test/pleroma/stats_test.exs
	index c70603ab9..a9fbcc805 100644
	--- a/test/pleroma/stats_test.exs
	+++ b/test/pleroma/stats_test.exs
	@@ -1,122 +1,122 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.StatsTest do
	use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Stats
	alias Pleroma.Web.CommonAPI

	describe "user count" do
	test "it ignores internal users" do
	_user = insert(:user, local: true)
	_internal = insert(:user, local: true, nickname: nil)
	_internal = Pleroma.Web.ActivityPub.Relay.get_actor()

	assert match?(%{stats: %{user_count: 1}}, Stats.calculate_stat_data())
	end
	end

	describe "status visibility sum count" do
	test "on new status" do
	instance2 = "instance2.tld"
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://#{instance2}/@actor"})

	CommonAPI.post(user, %{visibility: "public", status: "hey"})

	Enum.each(0..1, fn _ ->
	CommonAPI.post(user, %{
	visibility: "unlisted",
	status: "hey"
	})
	end)

	Enum.each(0..2, fn _ ->
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "hey @#{other_user.nickname}"
	})
	end)

	Enum.each(0..3, fn _ ->
	CommonAPI.post(user, %{
	visibility: "private",
	status: "hey"
	})
	end)

	assert %{"direct" => 3, "private" => 4, "public" => 1, "unlisted" => 2} =
	Stats.get_status_visibility_count()
	end

	test "on status delete" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
	assert %{"public" => 1} = Stats.get_status_visibility_count()
	CommonAPI.delete(activity.id, user)
	assert %{"public" => 0} = Stats.get_status_visibility_count()
	end

	test "on status visibility update" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
	assert %{"public" => 1, "private" => 0} = Stats.get_status_visibility_count()
	{:ok, _} = CommonAPI.update_activity_scope(activity.id, %{visibility: "private"})
	assert %{"public" => 0, "private" => 1} = Stats.get_status_visibility_count()
	end

	test "doesn't count unrelated activities" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
	_ = CommonAPI.follow(other_user, user)
	CommonAPI.favorite(activity.id, other_user)
	CommonAPI.repeat(activity.id, other_user)

	assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 0} =
	Stats.get_status_visibility_count()
	end
	end

	describe "status visibility by instance count" do
	test "single instance" do
	local_instance = Pleroma.Web.Endpoint.url() \|> String.split("//") \|> Enum.at(1)
	instance2 = "instance2.tld"
	user1 = insert(:user)
	user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})

	CommonAPI.post(user1, %{visibility: "public", status: "hey"})

	Enum.each(1..5, fn _ ->
	CommonAPI.post(user1, %{
	visibility: "unlisted",
	status: "hey"
	})
	end)

	Enum.each(1..10, fn _ ->
	CommonAPI.post(user1, %{
	visibility: "direct",
	status: "hey @#{user2.nickname}"
	})
	end)

	Enum.each(1..20, fn _ ->
	- CommonAPI.post(user2, %{
	+ post_as_remote(user2, %{
	visibility: "private",
	status: "hey"
	})
	end)

	assert %{"direct" => 10, "private" => 0, "public" => 1, "unlisted" => 5} =
	Stats.get_status_visibility_count(local_instance)

	assert %{"direct" => 0, "private" => 20, "public" => 0, "unlisted" => 0} =
	Stats.get_status_visibility_count(instance2)
	end
	end
	end
	diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
	index f4b92adf8..a0540b456 100644
	--- a/test/pleroma/user/backup_test.exs
	+++ b/test/pleroma/user/backup_test.exs
	@@ -1,339 +1,339 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.BackupTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	import Pleroma.Factory
	import Swoosh.TestAssertions
	import Mox

	alias Pleroma.Bookmark
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Uploaders.S3.ExAwsMock
	alias Pleroma.User.Backup
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.BackupWorker

	setup do
	clear_config([Pleroma.Upload, :uploader])
	clear_config([Backup, :limit_days])
	clear_config([Pleroma.Emails.Mailer, :enabled], true)

	ConfigMock
	\|> stub_with(Pleroma.Config)

	:ok
	end

	test "it does not requrie enabled email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	user = insert(:user)
	assert {:ok, _} = Backup.user(user)
	end

	test "it does not require user's email" do
	user = insert(:user, %{email: nil})
	assert {:ok, _} = Backup.user(user)
	end

	test "it creates a backup record and an Oban job" do
	user = insert(:user)
	assert {:ok, %Backup{} = backup} = Backup.user(user)
	assert {:ok, %Oban.Job{args: args}} = Backup.schedule_backup(backup)
	assert_enqueued(worker: BackupWorker, args: args)

	backup = Backup.get_by_id(args["backup_id"])
	assert %Backup{processed: false, file_size: 0} = backup
	end

	test "it return an error if the export limit is over" do
	user = insert(:user)
	limit_days = Pleroma.Config.get([Backup, :limit_days])
	{:ok, first_backup} = Backup.user(user)
	{:ok, _run_backup} = Backup.run(first_backup)

	assert Backup.user(user) == {:error, "Last export was less than #{limit_days} days ago"}
	end

	test "it process a backup record" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Backup{id: backup_id}} = Backup.user(user)

	oban_args = %{"op" => "process", "backup_id" => backup_id}

	assert {:ok, backup} = perform_job(BackupWorker, oban_args)
	assert backup.file_size > 0
	assert match?(%Backup{id: ^backup_id, processed: true, user_id: ^user_id}, backup)

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get_by_id(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it does not send an email if the user does not have an email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: nil})

	assert {:ok, %Backup{} = backup} = Backup.user(user)

	expected_args = %{"op" => "process", "backup_id" => backup.id}

	assert_enqueued(worker: BackupWorker, args: %{"backup_id" => backup.id})
	assert {:ok, completed_backup} = perform_job(BackupWorker, expected_args)
	assert completed_backup.file_size > 0
	assert completed_backup.processed
	assert completed_backup.user_id == user_id

	assert_no_email_sent()
	end

	test "it does not send an email if mailer is not on" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Backup{id: backup_id}} = Backup.user(user)

	oban_args = %{"op" => "process", "backup_id" => backup_id}

	assert {:ok, backup} = perform_job(BackupWorker, oban_args)
	assert backup.file_size > 0
	assert match?(%Backup{id: ^backup_id, processed: true, user_id: ^user_id}, backup)

	assert_no_email_sent()
	end

	test "it does not send an email if the user has an empty email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: ""})

	assert {:ok, %Backup{id: backup_id} = backup} = Backup.user(user)

	expected_args = %{"op" => "process", "backup_id" => backup.id}

	assert_enqueued(worker: BackupWorker, args: expected_args)

	assert {:ok, backup} = perform_job(BackupWorker, expected_args)
	assert backup.file_size > 0
	assert match?(%Backup{id: ^backup_id, processed: true, user_id: ^user_id}, backup)

	assert_no_email_sent()
	end

	test "it removes outdated backups after creating a fresh one" do
	clear_config([Backup, :limit_days], -1)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	user = insert(:user)

	assert {:ok, %{id: backup_one_id}} = Backup.user(user)
	assert {:ok, %{id: _backup_two_id}} = Backup.user(user)

	# Run the backups
	ObanHelpers.perform_all()

	assert_enqueued(worker: BackupWorker, args: %{"op" => "delete", "backup_id" => backup_one_id})
	end

	test "it creates a zip archive with user data" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
	%{ap_id: other_ap_id} = other_user = insert(:user)

	{:ok, %{object: %{data: %{"id" => id1}}} = status1} =
	- CommonAPI.post(user, %{status: "status1"})
	+ post_as_remote(user, %{status: "status1"})

	{:ok, %{object: %{data: %{"id" => id2}}} = status2} =
	- CommonAPI.post(user, %{status: "status2"})
	+ post_as_remote(user, %{status: "status2"})

	{:ok, %{object: %{data: %{"id" => id3}}} = status3} =
	- CommonAPI.post(user, %{status: "status3"})
	+ post_as_remote(user, %{status: "status3"})

	CommonAPI.favorite(status1.id, user)
	CommonAPI.favorite(status2.id, user)

	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	CommonAPI.follow(other_user, user)

	assert {:ok, backup} = Backup.user(user)
	assert {:ok, run_backup} = Backup.run(backup)

	tempfile = Path.join([run_backup.tempdir, run_backup.file_name])

	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(tempfile), [:memory])
	assert {:ok, {~c"actor.json", json}} = :zip.zip_get(~c"actor.json", zipfile)

	assert %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{"@language" => "und"}
	],
	"bookmarks" => "bookmarks.json",
	"followers" => "followers.json",
	"following" => "following.json",
	"id" => "http://cofe.io/users/cofe",
	"inbox" => "http://cofe.io/users/cofe/inbox",
	"likes" => "likes.json",
	"name" => "Cofe",
	"outbox" => "outbox.json",
	"preferredUsername" => "cofe",
	"publicKey" => %{
	"id" => "http://cofe.io/users/cofe#main-key",
	"owner" => "http://cofe.io/users/cofe"
	},
	"type" => "Person",
	"url" => "http://cofe.io/users/cofe"
	} = Jason.decode!(json)

	assert {:ok, {~c"outbox.json", json}} = :zip.zip_get(~c"outbox.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "outbox.json",
	"orderedItems" => [
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status1",
	"type" => "Note"
	},
	"type" => "Create"
	},
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status2"
	}
	},
	%{
	"actor" => "http://cofe.io/users/cofe",
	"object" => %{
	"content" => "status3"
	}
	}
	],
	"totalItems" => 3,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {~c"likes.json", json}} = :zip.zip_get(~c"likes.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "likes.json",
	"orderedItems" => [^id1, ^id2],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {~c"bookmarks.json", json}} = :zip.zip_get(~c"bookmarks.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "bookmarks.json",
	"orderedItems" => [^id2, ^id3],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {~c"following.json", json}} = :zip.zip_get(~c"following.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "following.json",
	"orderedItems" => [^other_ap_id],
	"totalItems" => 1,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	:zip.zip_close(zipfile)
	File.rm_rf!(run_backup.tempdir)
	end

	test "correct number processed" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	Enum.map(1..120, fn i ->
	- {:ok, status} = CommonAPI.post(user, %{status: "status #{i}"})
	+ {:ok, status} = post_as_remote(user, %{status: "status #{i}"})
	CommonAPI.favorite(status.id, user)
	Bookmark.create(user.id, status.id)
	end)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	{:ok, backup} = Backup.run(backup)

	zip_path = Path.join([backup.tempdir, backup.file_name])

	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(zip_path), [:memory])

	backup_parts = [~c"likes.json", ~c"bookmarks.json", ~c"outbox.json"]

	Enum.each(backup_parts, fn part ->
	assert {:ok, {_part, part_json}} = :zip.zip_get(part, zipfile)
	{:ok, decoded_part} = Jason.decode(part_json)
	assert decoded_part["totalItems"] == 120
	end)

	Backup.delete_archive(backup)
	end

	describe "it uploads and deletes a backup archive" do
	setup do
	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
	clear_config([Pleroma.Uploaders.S3, :bucket], "test_bucket")

	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	- {:ok, status1} = CommonAPI.post(user, %{status: "status1"})
	- {:ok, status2} = CommonAPI.post(user, %{status: "status2"})
	- {:ok, status3} = CommonAPI.post(user, %{status: "status3"})
	+ {:ok, status1} = post_as_remote(user, %{status: "status1"})
	+ {:ok, status2} = post_as_remote(user, %{status: "status2"})
	+ {:ok, status3} = post_as_remote(user, %{status: "status3"})
	CommonAPI.favorite(status1.id, user)
	CommonAPI.favorite(status2.id, user)
	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()

	[backup: backup]
	end

	test "S3", %{backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
	clear_config([Pleroma.Uploaders.S3, :streaming_enabled], false)

	ExAwsMock
	\|> expect(:request, 2, fn
	%{http_method: :put} -> {:ok, :ok}
	%{http_method: :delete} -> {:ok, %{status_code: 204}}
	end)

	assert {:ok, backup} = Backup.run(backup)
	assert {:ok, %Backup{processed: true}} = Backup.upload(backup)
	assert {:ok, _backup} = Backup.delete_archive(backup)
	end

	test "Local", %{backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	assert {:ok, backup} = Backup.run(backup)
	assert {:ok, %Backup{processed: true}} = Backup.upload(backup)
	assert {:ok, _backup} = Backup.delete_archive(backup)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_test.exs b/test/pleroma/web/activity_pub/activity_pub_test.exs
	index ed6db558b..91f9cd2ed 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_test.exs
	@@ -1,2978 +1,2933 @@
	# 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.ActivityPubTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Webhook.Notify

	import ExUnit.CaptureLog
	import Mock
	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

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

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it returns a user that accepts chat messages" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.accepts_chat_messages
	end

	test "works for guppe actors" do
	user_id = "https://gup.pe/u/bernie2020"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/guppe-actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.name == "Bernie2020 group"
	assert user.actor_type == "Group"
	end

	test "works for bridgy actors" do
	user_id = "https://fed.brid.gy/jk.nipponalba.scot"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/bridgy/actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.actor_type == "Person"

	assert user.avatar == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}],
	"name" => "profile picture"
	}

	assert user.banner == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}],
	"name" => "profile picture"
	}
	end

	test "fetches user featured collection" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

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

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

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

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

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user featured collection without embedded object" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/external_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

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

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

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

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

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user featured collection from the first collection page" do
	ap_id = "https://example.com/users/lain"
	featured_url = "https://example.com/users/lain/collections/featured"
	first_page_url = "#{featured_url}?page=true"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()
	object_url = "https://example.com/objects/#{object_id}"

	featured_data =
	Jason.encode!(%{
	"id" => featured_url,
	"type" => "OrderedCollection",
	"first" => first_page_url
	})

	first_page_data =
	Jason.encode!(%{
	"id" => first_page_url,
	"type" => "OrderedCollectionPage",
	"partOf" => featured_url,
	"orderedItems" => [object_url]
	})

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

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

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

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

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

	refute capture_log(fn ->
	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)
	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end) =~ "Could not parse featured collection"
	end

	test "fetches user birthday information from misskey" do
	user_id = "https://misskey.io/@mkljczk"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^user_id
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/birthdays/misskey-user.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.birthday == ~D[2001-02-12]
	end

	test "fetches avatar description" do
	user_id = "https://example.com/users/marcin"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "marcin")
	\|> Jason.decode!()
	\|> Map.delete("featured")
	\|> Map.update("icon", %{}, fn image -> Map.put(image, "name", "image description") end)
	\|> Jason.encode!()

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.avatar["name"] == "image description"
	end
	end

	test "works with avatar/banner href as list" do
	user_id = "https://queef.in/cute_cat"

	user_data =
	"test/fixtures/users_mock/href_as_array.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> Map.delete("featured")
	\|> Jason.encode!()

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert length(user.avatar["url"]) == 1
	assert length(user.banner["url"]) == 1

	assert user.avatar["url"] \|> List.first() \|> Map.fetch!("href") ==
	"https://queef.in/storage/profile.webp"

	assert user.banner["url"] \|> List.first() \|> Map.fetch!("href") ==
	"https://queef.in/storage/banner.gif"
	end

	test "works with alsoKnownAs as string" do
	user_id = "https://hub.netzgemeinde.eu/channel/jupiter_rowland"

	user_data =
	"test/fixtures/users_mock/hubzilla-actor-alsoknownas-string.json"
	\|> File.read!()

	user_data_decoded =
	user_data
	\|> Jason.decode!()

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert is_list(user.also_known_as)
	assert user.also_known_as == [user_data_decoded["alsoKnownAs"]]
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #TEST"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #Reject"})

	{:ok, status_four} = CommonAPI.post(user, %{status: ". #Any1 #any2"})
	{:ok, status_five} = CommonAPI.post(user, %{status: ". #Any2 #any1"})

	for hashtag_timeline_strategy <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_strategy)

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["TEST", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "Essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "REJECT"]
	})

	# Testing that deduplication (if needed) is done on DB (not Ecto) level; :limit is important
	fetch_five =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["ANY1", "any2"],
	limit: 2
	})

	fetch_six =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["any1", "Any2"],
	tag_all: [],
	tag_reject: []
	})

	# Regression test: passing empty lists as filter options shouldn't affect the results
	assert fetch_five == fetch_six

	[fetch_one, fetch_two, fetch_three, fetch_four, fetch_five] =
	Enum.map([fetch_one, fetch_two, fetch_three, fetch_four, fetch_five], fn statuses ->
	Enum.map(statuses, fn s -> Repo.preload(s, object: :hashtags) end)
	end)

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	assert fetch_five == [status_four, status_five]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity, fetch: false)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity, fetch: false)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{type: ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	- test "it reverts create", %{user: user} do
	- with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	- assert {:error, :reverted} =
	- ActivityPub.create(%{
	- to: ["user1", "user2"],
	- actor: user,
	- context: "",
	- object: %{
	- "to" => ["user1", "user2"],
	- "type" => "Note",
	- "content" => "testing"
	- }
	- })
	- end
	-
	- assert Repo.aggregate(Activity, :count, :id) == 0
	- assert Repo.aggregate(Object, :count, :id) == 0
	- end
	-
	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	- assert {:ok, _} =
	- ActivityPub.create(%{
	- to: ["user1", "user2"],
	- actor: user,
	- context: "",
	- object: %{
	- "to" => ["user1", "user2"],
	- "type" => "Note",
	- "content" => "testing"
	- }
	- })
	+ assert {:ok, _} = CommonAPI.post(user, %{status: "testing"})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	- ActivityPub.create(%{
	- to: ["user1", "user2"],
	- actor: user,
	- context: "",
	- object: %{
	- "to" => ["user1", "user2"],
	- "type" => "Note",
	- "content" => "testing"
	- },
	- additional: %{
	- "expires_at" => DateTime.utc_now()
	- }
	- })
	+ CommonAPI.post(user, %{status: "testing", expires_in: 100_000})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	+ other_user = insert(:user)
	+
	{:ok, activity} =
	- ActivityPub.create(%{
	- to: ["user1", "user1", "user2"],
	- actor: user,
	- context: "",
	- object: %{
	- "to" => ["user1", "user1", "user2"],
	- "type" => "Note",
	- "content" => "testing"
	- }
	+ CommonAPI.post(user, %{
	+ status: "@#{other_user.nickname} @#{other_user.nickname} testing",
	+ visibility: "direct"
	})

	- assert activity.data["to"] == ["user1", "user2"]
	+ assert activity.data["to"] == [other_user.ap_id]
	assert activity.actor == user.ap_id
	- assert activity.recipients == ["user1", "user2", user.ap_id]
	+ assert Enum.sort(activity.recipients) == Enum.sort([other_user.ap_id, user.ap_id])
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end

	test "increases quotes count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	quote_data = %{status: "1", quoted_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities for followed hashtags" do
	test "it should return public activities that reference a given hashtag" do
	hashtag = insert(:hashtag, name: "tenshi")
	user = insert(:user)
	other_user = insert(:user)

	{:ok, normally_visible} =
	CommonAPI.post(other_user, %{status: "hello :)", visibility: "public"})

	{:ok, public} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "public"})
	{:ok, _unrelated} = CommonAPI.post(user, %{status: "dai #tensh", visibility: "public"})
	{:ok, unlisted} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "unlisted"})
	{:ok, _private} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([other_user.follower_address], %{
	followed_hashtags: [hashtag.id]
	})

	assert length(activities) == 3
	normal_id = normally_visible.id
	public_id = public.id
	unlisted_id = unlisted.id
	assert [%{id: ^normal_id}, %{id: ^public_id}, %{id: ^unlisted_id}] = activities
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	insert(:filter, user: user, phrase: "test", hide: true)

	{:ok, %{id: id1, data: %{"context" => context}}} = CommonAPI.post(user, %{status: "1"})

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	\|> ActivityPub.fetch_activities_for_context(%{user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return activities from deactivated users" do
	_user = insert(:user)
	deactivated = insert(:user)
	active = insert(:user)
	{:ok, activity_one} = CommonAPI.post(deactivated, %{status: "hey!"})
	{:ok, activity_two} = CommonAPI.post(active, %{status: "yay!"})
	{:ok, _updated_user} = User.set_activation(deactivated, false)

	activities = ActivityPub.fetch_activities([], %{})

	refute Enum.member?(activities, activity_one)
	assert Enum.member?(activities, activity_two)
	end

	test "always see your own posts even when they address people you block" do
	user = insert(:user)
	blockee = insert(:user)

	{:ok, _} = User.block(user, blockee)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{blockee.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two, fetch: false)

	data = %{
	"actor" => friend.ap_id,
	"object" => object.data["id"],
	"context" => object.data["context"],
	"type" => "Announce",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [blockee.ap_id]
	}

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(followed_user, user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "see your own posts even when they address actors from blocked domains" do
	user = insert(:user)

	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})

	{:ok, user} = User.block_domain(user, domain)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{domain_user.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker, domain_user} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "returns your own posts regardless of mute" do
	user = insert(:user)
	muted = insert(:user)

	{:ok, muted_post} = CommonAPI.post(muted, %{status: "Im stupid"})

	{:ok, reply} =
	CommonAPI.post(user, %{status: "I'm muting you", in_reply_to_status_id: muted_post.id})

	{:ok, _} = User.mute(user, muted)

	[activity] = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert activity.id == reply.id
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user, booster} = User.follow(user, booster)

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	test "includes only reblogs on request" do
	user = insert(:user)
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{only_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	insert(:filter, user: user_two, phrase: "cofe", hide: true)
	insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	insert(:filter, user: user_two, phrase: "test", hide: false)

	params = %{
	type: ["Create", "Announce"],
	user: user_two
	}

	{:ok, %{user: user, user_two: user_two, params: params}}
	end

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(booster, user)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "strips / from filename", %{test_file: %Plug.Upload{} = file} do
	file = %{file \| filename: "../../../../../nested/bad.jpg"}
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	[%{"href" => href}] = object.data["url"]
	assert Regex.match?(~r"/bad.jpg$", href)
	refute Regex.match?(~r"/nested/", href)
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "it sets the default description depending on the configuration", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description])

	clear_config([Pleroma.Upload, :default_description], nil)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == ""

	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"

	clear_config([Pleroma.Upload, :default_description], "unnamed attachment")
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "unnamed attachment"
	end

	test "copies the file to the configured folder", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{is_locked: true})

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1, user3} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2, user3} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3, user2} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]
	object_ap_id = activity.object.data["id"]

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity_with_object.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "reverts on error",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	maybe_federate: fn _ -> {:error, :reverted} end do
	assert {:error, :reverted} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.aggregate(Object, :count, :id) == 1
	assert Repo.aggregate(Notification, :count, :id) == 0
	end

	test_with_mock "triggers webhooks",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Notify,
	[:passthrough],
	trigger_webhooks: fn _, _ -> nil end do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert_called(Notify.trigger_webhooks(activity, :"report.created"))
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create(%{title: "foo"}, user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, %Activity{} = activity} =
	CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "synchronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/fuser2/followers",
	following_address: "https://remote.org/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"https://remote.org/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

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

	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"https://remote.org/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

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

	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/followers/fuser3",
	following_address: "https://remote.org/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"https://remote.org/users/masto_hidden_counters/following" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "https://remote.org/users/masto_hidden_counters/followers"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"https://remote.org/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"https://remote.org/users/masto_hidden_counters/followers" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "https://remote.org/users/masto_hidden_counters/following"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"https://remote.org/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_hidden_counters/followers",
	following_address: "https://remote.org/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(a4.id, user)
	{:ok, _} = CommonAPI.favorite(a3.id, other_user)
	{:ok, _} = CommonAPI.favorite(a3.id, user)
	{:ok, _} = CommonAPI.favorite(a5.id, other_user)
	{:ok, _} = CommonAPI.favorite(a5.id, user)
	{:ok, _} = CommonAPI.favorite(a4.id, other_user)
	{:ok, _} = CommonAPI.favorite(a1.id, user)
	{:ok, _} = CommonAPI.favorite(a1.id, other_user)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

	User.follow(follower, old_user)
	User.follow(follower_move_opted_out, old_user)

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, %Activity{} = activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true,
	recipients: recipients
	} = activity

	assert old_user.follower_address in recipients

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end

	test "do not move remote user following relationships" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower_remote = insert(:user, local: false)

	User.follow(follower_remote, old_user)

	assert User.following?(follower_remote, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	assert User.following?(follower_remote, old_user)
	refute User.following?(follower_remote, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

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

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

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

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

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

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u3} = User.follow(u1, u3)
	{:ok, u3, u1} = User.follow(u3, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at:
	activity.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end

	describe "reply filtering" do
	test "`following` still contains announcements by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})

	{:ok, not_followed_to_followed} =
	CommonAPI.post(not_followed, %{
	status: "Also hello",
	in_reply_to_status_id: followed_post.id
	})

	{:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

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

	followed_post_id = followed_post.id
	retoot_id = retoot.id

	assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities

	assert length(activities) == 2
	end

	# This test is skipped because, while this is the desired behavior,
	# there seems to be no good way to achieve it with the method that
	# we currently use for detecting to who a reply is directed.
	# This is a TODO and should be fixed by a later rewrite of the code
	# in question.
	@tag skip: true
	test "`following` still contains self-replies by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	{:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})

	{:ok, _followed_to_not_followed} =
	CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})

	{:ok, _followed_self_reply} =
	CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

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

	assert length(activities) == 2
	end
	end

	test "allow fetching of accounts with an empty string name field" do
	Tesla.Mock.mock(fn
	%{method: :get, url: "https://princess.cat/users/mewmew"} ->
	file = File.read!("test/fixtures/mewmew_no_name.json")
	%Tesla.Env{status: 200, body: file, headers: HttpRequestMock.activitypub_object_headers()}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id("https://princess.cat/users/mewmew")
	assert user.name == " "
	end

	test "pin_data_from_featured_collection will ignore unsupported values" do
	assert %{} ==
	ActivityPub.pin_data_from_featured_collection(%{
	"type" => "OrderedCollection",
	"first" => "https://social.example/users/alice/collections/featured?page=true"
	})
	end

	test "fetch_and_prepare_featured_from_ap_id handles embedded first collection pages" do
	featured_url = "https://social.example/users/alice/collections/featured"
	first_page_url = "#{featured_url}?page=true"
	object_url = "https://social.example/objects/1"

	featured_data =
	Jason.encode!(%{
	"id" => featured_url,
	"type" => "OrderedCollection",
	"first" => %{
	"id" => first_page_url,
	"type" => "OrderedCollectionPage",
	"partOf" => featured_url,
	"orderedItems" => [object_url]
	}
	})

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

	refute capture_log(fn ->
	assert {:ok, pinned_objects} =
	ActivityPub.fetch_and_prepare_featured_from_ap_id(featured_url)

	assert Map.has_key?(pinned_objects, object_url)
	end) =~ "Could not parse featured collection"
	end
	end
	diff --git a/test/pleroma/web/activity_pub/builder_test.exs b/test/pleroma/web/activity_pub/builder_test.exs
	index 52058a0a3..c7a807a71 100644
	--- a/test/pleroma/web/activity_pub/builder_test.exs
	+++ b/test/pleroma/web/activity_pub/builder_test.exs
	@@ -1,77 +1,88 @@
	# 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.BuilderTest do
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.CommonAPI.ActivityDraft
	use Pleroma.DataCase

	import Pleroma.Factory

	describe "note/1" do
	test "returns note data" do
	user = insert(:user)
	note = insert(:note)
	user2 = insert(:user)
	user3 = insert(:user)

	draft = %ActivityDraft{
	user: user,
	to: [user2.ap_id],
	context: "2hu",
	content_html: "<h1>This is :moominmamma: note</h1>",
	in_reply_to: note.id,
	tags: [name: "jimm"],
	summary: "test summary",
	cc: [user3.ap_id],
	extra: %{"custom_tag" => "test"}
	}

	expected = %{
	"actor" => user.ap_id,
	"attachment" => [],
	"cc" => [user3.ap_id],
	"content" => "<h1>This is :moominmamma: note</h1>",
	"context" => "2hu",
	"sensitive" => false,
	"summary" => "test summary",
	- "tag" => ["jimm"],
	+ "tag" => [
	+ %{
	+ "href" => Pleroma.Web.Endpoint.url() <> "/tags/jimm",
	+ "name" => "#jimm",
	+ "type" => "Hashtag"
	+ }
	+ ],
	"to" => [user2.ap_id],
	"type" => "Note",
	"custom_tag" => "test"
	}

	- assert {:ok, ^expected, []} = Builder.note(draft)
	+ assert {:ok, %{"id" => "http" <> _, "published" => published} = data, []} =
	+ Builder.note(draft)
	+
	+ assert {:ok, _, _} = DateTime.from_iso8601(published)
	+ assert Map.drop(data, ["id", "published"]) == expected
	end

	test "quote post" do
	user = insert(:user)
	note = insert(:note)

	draft = %ActivityDraft{
	user: user,
	context: "2hu",
	content_html: "<h1>This is :moominmamma: note</h1>",
	quote_post: note,
	extra: %{}
	}

	expected = %{
	"actor" => user.ap_id,
	"attachment" => [],
	"content" => "<h1>This is :moominmamma: note</h1>",
	"context" => "2hu",
	"sensitive" => false,
	"type" => "Note",
	"quoteUrl" => note.data["id"],
	"cc" => [],
	"summary" => nil,
	"tag" => [],
	"to" => []
	}

	- assert {:ok, ^expected, []} = Builder.note(draft)
	+ assert {:ok, %{"id" => "http" <> _, "published" => _} = data, []} = Builder.note(draft)
	+ assert Map.drop(data, ["id", "published"]) == expected
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/force_mentions_in_content_test.exs b/test/pleroma/web/activity_pub/mrf/force_mentions_in_content_test.exs
	index 811ef105c..27f31b334 100644
	--- a/test/pleroma/web/activity_pub/mrf/force_mentions_in_content_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/force_mentions_in_content_test.exs
	@@ -1,310 +1,314 @@
	# 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.MRF.ForceMentionsInContentTest do
	use Pleroma.DataCase
	require Pleroma.Constants

	alias Pleroma.Constants
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.MRF.ForceMentionsInContent
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "adds mentions to post content" do
	[lain, coolboymew, dielan, hakui, fence] = [
	- insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain@lain.com", local: false),
	+ insert(:user,
	+ ap_id: "https://lain.com/users/lain",
	+ nickname: "lain@lain.com",
	+ local: false
	+ ),
	insert(:user,
	ap_id: "https://shitposter.club/users/coolboymew",
	nickname: "coolboymew@shitposter.club",
	local: false
	),
	insert(:user,
	ap_id: "https://shitposter.club/users/dielan",
	nickname: "dielan@shitposter.club",
	local: false
	),
	insert(:user,
	ap_id: "https://tuusin.misono-ya.info/users/hakui",
	nickname: "hakui@tuusin.misono-ya.info",
	local: false
	),
	insert(:user,
	ap_id: "https://xyzzy.link/users/fence",
	nickname: "fence@xyzzy.link",
	local: false
	)
	]

	object = File.read!("test/fixtures/soapbox_no_mentions_in_content.json") \|> Jason.decode!()

	activity = %{
	"type" => "Create",
	"actor" => "https://gleasonator.com/users/alex",
	"object" => object
	}

	{:ok, %{"object" => %{"content" => filtered}}} = ForceMentionsInContent.filter(activity)

	assert filtered ==
	"<p><span class=\"recipients-inline\"><span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{dielan.id}\" href=\"https://shitposter.club/users/dielan\" rel=\"ugc\">@<span>dielan</span></a></span> <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{coolboymew.id}\" href=\"https://shitposter.club/users/coolboymew\" rel=\"ugc\">@<span>coolboymew</span></a></span> <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{fence.id}\" href=\"https://xyzzy.link/users/fence\" rel=\"ugc\">@<span>fence</span></a></span> <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{hakui.id}\" href=\"https://tuusin.misono-ya.info/users/hakui\" rel=\"ugc\">@<span>hakui</span></a></span> <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{lain.id}\" href=\"https://lain.com/users/lain\" rel=\"ugc\">@<span>lain</span></a></span> </span>Haha yeah, you can control who you reply to.</p>"
	end

	test "the replied-to user is sorted to the left" do
	[mario, luigi, wario] = [
	insert(:user, nickname: "mario"),
	insert(:user, nickname: "luigi"),
	insert(:user, nickname: "wario")
	]

	{:ok, post1} = CommonAPI.post(mario, %{status: "Letsa go!"})

	{:ok, post2} =
	CommonAPI.post(luigi, %{status: "Oh yaah", in_reply_to_id: post1.id, to: [mario.ap_id]})

	activity = %{
	"type" => "Create",
	"actor" => wario.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => wario.ap_id,
	"content" => "WHA-HA!",
	"to" => [
	mario.ap_id,
	luigi.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => Object.normalize(post2).data["id"]
	}
	}

	{:ok, %{"object" => %{"content" => filtered}}} = ForceMentionsInContent.filter(activity)

	assert filtered ==
	"<span class=\"recipients-inline\"><span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{luigi.id}\" href=\"#{luigi.ap_id}\" rel=\"ugc\">@<span>luigi</span></a></span> <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{mario.id}\" href=\"#{mario.ap_id}\" rel=\"ugc\">@<span>mario</span></a></span> </span>WHA-HA!"
	end

	test "don't mention self" do
	mario = insert(:user, nickname: "mario")

	{:ok, post} = CommonAPI.post(mario, %{status: "Mama mia"})

	activity = %{
	"type" => "Create",
	"actor" => mario.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => mario.ap_id,
	"content" => "I'ma tired...",
	"to" => [
	mario.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => Object.normalize(post).data["id"]
	}
	}

	{:ok, %{"object" => %{"content" => filtered}}} = ForceMentionsInContent.filter(activity)
	assert filtered == "I'ma tired..."
	end

	test "don't mention in top-level posts" do
	mario = insert(:user, nickname: "mario")
	luigi = insert(:user, nickname: "luigi")

	{:ok, post} = CommonAPI.post(mario, %{status: "Letsa go"})

	activity = %{
	"type" => "Create",
	"actor" => mario.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => mario.ap_id,
	"content" => "Mama mia!",
	"to" => [
	luigi.ap_id,
	Constants.as_public()
	],
	"quoteUrl" => Object.normalize(post).data["id"]
	}
	}

	{:ok, %{"object" => %{"content" => filtered}}} = ForceMentionsInContent.filter(activity)
	assert filtered == "Mama mia!"
	end

	test "with markdown formatting" do
	mario = insert(:user, nickname: "mario")
	luigi = insert(:user, nickname: "luigi")

	{:ok, post} = CommonAPI.post(luigi, %{status: "Mama mia"})

	activity = %{
	"type" => "Create",
	"actor" => mario.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => mario.ap_id,
	"content" => "<p>I'ma tired...</p>",
	"to" => [
	luigi.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => Object.normalize(post).data["id"]
	}
	}

	{:ok, %{"object" => %{"content" => filtered}}} = ForceMentionsInContent.filter(activity)

	assert filtered ==
	"<p><span class=\"recipients-inline\"><span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{luigi.id}\" href=\"#{luigi.ap_id}\" rel=\"ugc\">@<span>luigi</span></a></span> </span>I'ma tired...</p>"
	end

	test "aware of history" do
	mario = insert(:user, nickname: "mario")
	wario = insert(:user, nickname: "wario")

	{:ok, post1} = CommonAPI.post(mario, %{status: "Letsa go!"})

	activity = %{
	"type" => "Create",
	"actor" => wario.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => wario.ap_id,
	"content" => "WHA-HA!",
	"to" => [
	mario.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => post1.object.data["id"],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"type" => "Note",
	"actor" => wario.ap_id,
	"content" => "WHA-HA!",
	"to" => [
	mario.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => post1.object.data["id"]
	}
	]
	}
	}
	}

	expected =
	"<span class=\"recipients-inline\"><span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{mario.id}\" href=\"#{mario.ap_id}\" rel=\"ugc\">@<span>mario</span></a></span> </span>WHA-HA!"

	assert {:ok,
	%{
	"object" => %{
	"content" => ^expected,
	"formerRepresentations" => %{"orderedItems" => [%{"content" => ^expected}]}
	}
	}} = MRF.filter_one(ForceMentionsInContent, activity)
	end

	test "works with Updates" do
	mario = insert(:user, nickname: "mario")
	wario = insert(:user, nickname: "wario")

	{:ok, post1} = CommonAPI.post(mario, %{status: "Letsa go!"})

	activity = %{
	"type" => "Update",
	"actor" => wario.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => wario.ap_id,
	"content" => "WHA-HA!",
	"to" => [
	mario.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => post1.object.data["id"],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"type" => "Note",
	"actor" => wario.ap_id,
	"content" => "WHA-HA!",
	"to" => [
	mario.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => post1.object.data["id"]
	}
	]
	}
	}
	}

	expected =
	"<span class=\"recipients-inline\"><span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{mario.id}\" href=\"#{mario.ap_id}\" rel=\"ugc\">@<span>mario</span></a></span> </span>WHA-HA!"

	assert {:ok,
	%{
	"object" => %{
	"content" => ^expected,
	"formerRepresentations" => %{"orderedItems" => [%{"content" => ^expected}]}
	}
	}} = MRF.filter_one(ForceMentionsInContent, activity)
	end

	test "don't add duplicate mentions for mastodon or misskey posts" do
	[zero, rogerick, greg] = [
	insert(:user,
	ap_id: "https://pleroma.example.com/users/zero",
	uri: "https://pleroma.example.com/users/zero",
	nickname: "zero@pleroma.example.com",
	local: false
	),
	insert(:user,
	ap_id: "https://misskey.example.com/users/104ab42f11",
	uri: "https://misskey.example.com/@rogerick",
	nickname: "rogerick@misskey.example.com",
	local: false
	),
	insert(:user,
	ap_id: "https://mastodon.example.com/users/greg",
	uri: "https://mastodon.example.com/@greg",
	nickname: "greg@mastodon.example.com",
	local: false
	)
	]

	- {:ok, post} = CommonAPI.post(rogerick, %{status: "eugh"})
	+ {:ok, post} = post_as_remote(rogerick, %{status: "eugh"})

	inline_mentions = [
	"<span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{rogerick.id}\" href=\"#{rogerick.ap_id}\" rel=\"ugc\">@<span>rogerick</span></a></span>",
	"<span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{greg.id}\" href=\"#{greg.uri}\" rel=\"ugc\">@<span>greg</span></a></span>"
	]

	activity = %{
	"type" => "Create",
	"actor" => zero.ap_id,
	"object" => %{
	"type" => "Note",
	"actor" => zero.ap_id,
	"content" => "#{Enum.at(inline_mentions, 0)} #{Enum.at(inline_mentions, 1)} erm",
	"to" => [
	rogerick.ap_id,
	greg.ap_id,
	Constants.as_public()
	],
	"inReplyTo" => Object.normalize(post).data["id"]
	}
	}

	{:ok, %{"object" => %{"content" => filtered}}} = ForceMentionsInContent.filter(activity)

	assert filtered ==
	"#{Enum.at(inline_mentions, 0)} #{Enum.at(inline_mentions, 1)} erm"
	end
	end
	diff --git a/test/pleroma/web/activity_pub/side_effects_test.exs b/test/pleroma/web/activity_pub/side_effects_test.exs
	index ac927a838..20de405a4 100644
	--- a/test/pleroma/web/activity_pub/side_effects_test.exs
	+++ b/test/pleroma/web/activity_pub/side_effects_test.exs
	@@ -1,1134 +1,1134 @@
	# 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.SideEffectsTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ActivityPubMock
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.ActivityDraft

	import Mock
	import Mox
	import Pleroma.Factory

	defp get_announces_of_object(%{data: %{"id" => id}} = _object) do
	Pleroma.Activity.Queries.by_type("Announce")
	\|> Pleroma.Activity.Queries.by_object_id(id)
	\|> Pleroma.Repo.all()
	end

	describe "handle_after_transaction" do
	test "it streams out notifications and streams" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert [notification] = meta[:notifications]

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	}
	]) do
	SideEffects.handle_after_transaction(meta)

	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	assert_enqueued(
	worker: "Pleroma.Workers.WebPusherWorker",
	args: %{"notification_id" => notification.id, "op" => "web_push"}
	)
	end
	end
	end

	describe "blocking users" do
	setup do
	user = insert(:user)
	blocked = insert(:user)
	User.follow(blocked, user)
	User.follow(user, blocked)

	{:ok, block_data, []} = Builder.block(user, blocked)
	{:ok, block, _meta} = ActivityPub.persist(block_data, local: true)

	%{user: user, blocked: blocked, block: block}
	end

	test "it unfollows and blocks", %{user: user, blocked: blocked, block: block} do
	assert User.following?(user, blocked)
	assert User.following?(blocked, user)

	{:ok, _, _} = SideEffects.handle(block)

	refute User.following?(user, blocked)
	refute User.following?(blocked, user)
	assert User.blocks?(user, blocked)
	end

	test "it updates following relationship", %{user: user, blocked: blocked, block: block} do
	{:ok, _, _} = SideEffects.handle(block)

	refute Pleroma.FollowingRelationship.get(user, blocked)
	assert User.get_follow_state(user, blocked) == nil
	assert User.get_follow_state(blocked, user) == nil
	assert User.get_follow_state(user, blocked, nil) == nil
	assert User.get_follow_state(blocked, user, nil) == nil
	end

	test "it blocks but does not unfollow if the relevant setting is set", %{
	user: user,
	blocked: blocked,
	block: block
	} do
	clear_config([:activitypub, :unfollow_blocked], false)
	assert User.following?(user, blocked)
	assert User.following?(blocked, user)

	{:ok, _, _} = SideEffects.handle(block)

	refute User.following?(user, blocked)
	assert User.following?(blocked, user)
	assert User.blocks?(user, blocked)
	end
	end

	describe "update users" do
	setup do
	user = insert(:user, local: false)

	{:ok, update_data, []} =
	Builder.update(user, %{"id" => user.ap_id, "type" => "Person", "name" => "new name!"})

	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	%{user: user, update_data: update_data, update: update}
	end

	test "it updates the user", %{user: user, update: update} do
	{:ok, _, _} = SideEffects.handle(update)
	user = User.get_by_id(user.id)
	assert user.name == "new name!"
	end

	test "it uses a given changeset to update", %{user: user, update: update} do
	changeset = Ecto.Changeset.change(user, %{default_scope: "direct"})

	assert user.default_scope == "public"
	{:ok, _, _} = SideEffects.handle(update, user_update_changeset: changeset)
	user = User.get_by_id(user.id)
	assert user.default_scope == "direct"
	end
	end

	describe "update notes" do
	setup do
	make_time = fn ->
	Pleroma.Web.ActivityPub.Utils.make_date()
	end

	user = insert(:user)
	note = insert(:note, user: user, data: %{"published" => make_time.()})
	_note_activity = insert(:note_activity, note: note)

	updated_note =
	note.data
	\|> Map.put("summary", "edited summary")
	\|> Map.put("content", "edited content")
	\|> Map.put("updated", make_time.())

	{:ok, update_data, []} = Builder.update(user, updated_note)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	%{
	user: user,
	note: note,
	object_id: note.id,
	update_data: update_data,
	update: update,
	updated_note: updated_note
	}
	end

	test "it updates the note", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	updated_time = updated_note["updated"]

	new_note = Pleroma.Object.get_by_id(object_id)

	assert %{
	"summary" => "edited summary",
	"content" => "edited content",
	"updated" => ^updated_time
	} = new_note.data
	end

	test "it streams out the update only after the transaction", %{
	update: update,
	updated_note: updated_note
	} do
	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, update, meta} = SideEffects.handle(update, object_data: updated_note)

	verify!()

	update_id = update.id

	ActivityPubMock
	\|> expect(:stream_out, fn %Activity{id: ^update_id, object: %Object{}} -> nil end)

	SideEffects.handle_after_transaction(meta)
	end

	test "it does not stream out rejected updates", %{
	update: update,
	updated_note: updated_note
	} do
	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	updated_note = Map.delete(updated_note, "updated")
	{:ok, _update, meta} = SideEffects.handle(update, object_data: updated_note)
	SideEffects.handle_after_transaction(meta)
	end

	test "it rejects updates with no updated attribute in object", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	updated_note = Map.drop(updated_note, ["updated"])
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it rejects updates with updated attribute older than what we have in the original object",
	%{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, creation_time, _} = DateTime.from_iso8601(old_note.data["published"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(creation_time, -10)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it rejects updates with updated attribute older than the last Update", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, creation_time, _} = DateTime.from_iso8601(old_note.data["published"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(creation_time, +10)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)

	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, update_time, _} = DateTime.from_iso8601(old_note.data["updated"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(update_time, -5)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)

	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it updates using object_data", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	updated_note = Map.put(updated_note, "summary", "mew mew")
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "mew mew", "content" => "edited content"} = new_note.data
	end

	test "it records the original note in formerRepresentations", %{
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary", "content" => "edited content"} = new_note

	assert [Map.drop(note.data, ["id", "formerRepresentations"])] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 1
	end

	test "it puts the original note at the front of formerRepresentations", %{
	user: user,
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: first_edit} = Pleroma.Object.get_by_id(object_id)

	second_updated_note =
	note.data
	\|> Map.put("summary", "edited summary 2")
	\|> Map.put("content", "edited content 2")
	\|> Map.put(
	"updated",
	first_edit["updated"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> DateTime.add(10)
	\|> DateTime.to_iso8601()
	)

	{:ok, second_update_data, []} = Builder.update(user, second_updated_note)
	{:ok, update, _meta} = ActivityPub.persist(second_update_data, local: true)
	{:ok, _, _} = SideEffects.handle(update, object_data: second_updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary 2", "content" => "edited content 2"} = new_note

	original_version = Map.drop(note.data, ["id", "formerRepresentations"])
	first_edit = Map.drop(first_edit, ["id", "formerRepresentations"])

	assert [first_edit, original_version] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 2
	end

	test "it does not prepend to formerRepresentations if no actual changes are made", %{
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: first_edit} = Pleroma.Object.get_by_id(object_id)

	updated_note =
	updated_note
	\|> Map.put(
	"updated",
	first_edit["updated"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> DateTime.add(10)
	\|> DateTime.to_iso8601()
	)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary", "content" => "edited content"} = new_note

	original_version = Map.drop(note.data, ["id", "formerRepresentations"])

	assert [original_version] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 1
	end
	end

	describe "update questions" do
	setup do
	user = insert(:user)

	question =
	insert(:question,
	user: user,
	data: %{"published" => Pleroma.Web.ActivityPub.Utils.make_date()}
	)

	%{user: user, data: question.data, id: question.id}
	end

	test "allows updating choice count without generating edit history", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)
	\|> Map.put("updated", Pleroma.Web.ActivityPub.Utils.make_date())

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end

	test "allows updating choice count without updated field", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end

	test "allows updating choice count with updated field same as the creation date", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)
	\|> Map.put("updated", data["published"])

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end
	end

	describe "EmojiReact objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
	{:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)

	%{emoji_react: emoji_react, user: user, poster: poster}
	end

	test "adds the reaction to the object", %{emoji_react: emoji_react, user: user} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	object = Object.get_by_ap_id(emoji_react.data["object"])

	assert object.data["reaction_count"] == 1
	assert ["👌", [user.ap_id], nil] in object.data["reactions"]
	end

	test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: emoji_react.id)
	end
	end

	describe "Question objects" do
	setup do
	user = insert(:user)
	question = build(:question, user: user)
	question_activity = build(:question_activity, question: question)
	activity_data = Map.put(question_activity.data, "object", question.data["id"])
	meta = [object_data: question.data, local: false]

	{:ok, activity, meta} = ActivityPub.persist(activity_data, meta)

	%{activity: activity, meta: meta}
	end

	test "enqueues the poll end", %{activity: activity, meta: meta} do
	{:ok, activity, meta} = SideEffects.handle(activity, meta)

	assert_enqueued(
	worker: Pleroma.Workers.PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: NaiveDateTime.from_iso8601!(meta[:object_data]["closed"])
	)
	end
	end

	describe "delete users with confirmation pending" do
	setup do
	user = insert(:user, is_confirmed: false)
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
	{:ok, delete: delete_user, user: user}
	end

	test "when activation is required", %{delete: delete, user: user} do
	clear_config([:instance, :account_activation_required], true)
	{:ok, _, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	refute User.get_cached_by_id(user.id)
	end
	end

	describe "Undo objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, like} = CommonAPI.favorite(post.id, user)
	{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
	{:ok, announce} = CommonAPI.repeat(post.id, user)
	{:ok, block} = CommonAPI.block(poster, user)

	{:ok, undo_data, _meta} = Builder.undo(user, like)
	{:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, reaction)
	{:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, announce)
	{:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, block)
	{:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	%{
	like_undo: like_undo,
	post: post,
	like: like,
	reaction_undo: reaction_undo,
	reaction: reaction,
	announce_undo: announce_undo,
	announce: announce,
	block_undo: block_undo,
	block: block,
	poster: poster,
	user: user
	}
	end

	test "deletes the original block", %{
	block_undo: block_undo,
	block: block
	} do
	{:ok, _block_undo, _meta} = SideEffects.handle(block_undo)

	refute Activity.get_by_id(block.id)
	end

	test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
	blocker = User.get_by_ap_id(block.data["actor"])
	blocked = User.get_by_ap_id(block.data["object"])

	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute User.blocks?(blocker, blocked)
	end

	test "an announce undo removes the announce from the object", %{
	announce_undo: announce_undo,
	post: post
	} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["announcement_count"] == 0
	assert object.data["announcements"] == []
	end

	test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
	refute Activity.get_by_id(announce.id)
	end

	test "a reaction undo removes the reaction from the object", %{
	reaction_undo: reaction_undo,
	post: post
	} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["reaction_count"] == 0
	assert object.data["reactions"] == []
	end

	test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
	refute Activity.get_by_id(reaction.id)
	end

	test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["like_count"] == 0
	assert object.data["likes"] == []
	end

	test "deletes the original like", %{like_undo: like_undo, like: like} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)
	refute Activity.get_by_id(like.id)
	end
	end

	describe "like objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, like_data, _meta} = Builder.like(user, post.object)
	{:ok, like, _meta} = ActivityPub.persist(like_data, local: true)

	%{like: like, user: user, poster: poster}
	end

	test "add the like to the original object", %{like: like, user: user} do
	{:ok, like, _} = SideEffects.handle(like)
	object = Object.get_by_ap_id(like.data["object"])
	assert object.data["like_count"] == 1
	assert user.ap_id in object.data["likes"]
	end

	test "creates a notification", %{like: like, poster: poster} do
	{:ok, like, _} = SideEffects.handle(like)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
	end
	end

	describe "creation of ChatMessages" do
	test "notifies the recipient" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert Repo.get_by(Notification, user_id: recipient.id, activity_id: create_activity.id)
	end

	test "it streams the created ChatMessage" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert [_, _] = meta[:streamables]
	end

	test "it creates a Chat and MessageReferences for the local users and bumps the unread count, except for the author" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# The notification gets created
	assert [notification] = meta[:notifications]
	assert notification.activity_id == create_activity.id

	# But it is not sent out
	refute called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	refute called(Pleroma.Web.Push.send(notification))

	# Same for the user chat stream
	assert [{topics, _}, _] = meta[:streamables]
	assert topics == ["user", "user:pleroma_chat"]
	refute called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	chat = Chat.get(author.id, recipient.ap_id)

	[cm_ref] = MessageReference.for_chat_query(chat) \|> Repo.all()

	assert cm_ref.object.data["content"] == "hey"
	assert cm_ref.unread == false

	chat = Chat.get(recipient.id, author.ap_id)

	[cm_ref] = MessageReference.for_chat_query(chat) \|> Repo.all()

	assert cm_ref.object.data["content"] == "hey"
	assert cm_ref.unread == true
	end
	end

	test "it creates a Chat for the local users and bumps the unread count" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# An object is created
	assert Object.get_by_ap_id(chat_message_data["id"])

	# The remote user won't get a chat
	chat = Chat.get(author.id, recipient.ap_id)
	refute chat

	# The local user will get a chat
	chat = Chat.get(recipient.id, author.ap_id)
	assert chat

	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# Both users are local and get the chat
	chat = Chat.get(author.id, recipient.ap_id)
	assert chat

	chat = Chat.get(recipient.id, author.ap_id)
	assert chat
	end
	end

	describe "creation of Notes" do
	setup do
	author = insert(:user, local: true)
	mentioned = insert(:user, local: true)

	{:ok, draft} = ActivityDraft.create(author, %{status: "hey @#{mentioned.nickname}"})
	{:ok, note_data, _meta} = Builder.note(draft)

	note_data =
	note_data
	\|> Map.put("id", Utils.generate_object_id())
	\|> Map.put("published", Utils.make_date())

	{:ok, create_data, _meta} = Builder.create(author, note_data["id"], note_data["to"])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_data, local: true)

	%{
	author: author,
	mentioned: mentioned,
	note_data: note_data,
	create_activity: create_activity
	}
	end

	test "it streams out the activity only after the transaction", %{
	create_activity: create_activity,
	note_data: note_data,
	mentioned: mentioned
	} do
	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, create_activity, meta} =
	SideEffects.handle(create_activity, local: true, object_data: note_data)

	verify!()

	assert [notification] = meta[:notifications]
	assert notification.user_id == mentioned.id

	ActivityPubMock
	\|> expect(:stream_out, fn ^create_activity -> nil end)

	SideEffects.handle_after_transaction(meta)
	end

	test "it creates a conversation for direct messages and queues the participations for streaming",
	%{author: author, mentioned: mentioned} do
	{:ok, draft} =
	ActivityDraft.create(author, %{
	status: "hey @#{mentioned.nickname}",
	visibility: "direct"
	})

	{:ok, note_data, _meta} = Builder.note(draft)

	note_data =
	note_data
	\|> Map.put("id", Utils.generate_object_id())
	\|> Map.put("published", Utils.make_date())

	{:ok, create_data, _meta} = Builder.create(author, note_data["id"], note_data["to"])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_data, local: true)

	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: true, object_data: note_data)

	assert [%Participation{read: true}] = Participation.for_user(author)
	assert [%Participation{read: false}] = Participation.for_user(mentioned)

	assert [{"participation", participations}] = meta[:streamables]

	assert Enum.map(participations, & &1.user.id) \|> Enum.sort() ==
	Enum.sort([author.id, mentioned.id])
	end

	test "it does not create a conversation for public posts", %{
	create_activity: create_activity,
	note_data: note_data,
	author: author
	} do
	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: true, object_data: note_data)

	assert [] == Participation.for_user(author)
	refute meta[:streamables]
	end
	end

	describe "announce objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, private_post} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, announce_data, _meta} = Builder.announce(user, post.object, visibility: "public")

	{:ok, private_announce_data, _meta} =
	Builder.announce(user, private_post.object, visibility: "private")

	{:ok, relay_announce_data, _meta} =
	Builder.announce(Pleroma.Web.ActivityPub.Relay.get_actor(), post.object,
	visibility: "public"
	)

	{:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)
	{:ok, private_announce, _meta} = ActivityPub.persist(private_announce_data, local: true)
	{:ok, relay_announce, _meta} = ActivityPub.persist(relay_announce_data, local: true)

	%{
	announce: announce,
	user: user,
	poster: poster,
	private_announce: private_announce,
	relay_announce: relay_announce
	}
	end

	test "adds the announce to the original object", %{announce: announce, user: user} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == 1
	assert user.ap_id in object.data["announcements"]
	end

	test "does not add the announce to the original object if the actor is a service actor", %{
	relay_announce: announce
	} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	- assert object.data["announcement_count"] == nil
	+ assert Map.get(object.data, "announcement_count", 0) == 0
	end

	test "creates a notification", %{announce: announce, poster: poster} do
	{:ok, announce, _} = SideEffects.handle(announce)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: announce.id)
	end

	test "streams out the announce only after the transaction", %{announce: announce} do
	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, announce, meta} = SideEffects.handle(announce)

	verify!()

	ActivityPubMock
	\|> expect(:stream_out, fn ^announce -> nil end)

	SideEffects.handle_after_transaction(meta)
	end

	test "does not stream out announces by internal actors", %{poster: poster} do
	internal_actor = Pleroma.Web.ActivityPub.InternalFetchActor.get_actor()
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, announce_data, _meta} =
	Builder.announce(internal_actor, post.object, visibility: "public")

	{:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)

	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, _announce, meta} = SideEffects.handle(announce)
	SideEffects.handle_after_transaction(meta)
	end
	end

	describe "removing a follower" do
	setup do
	user = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, user)

	{:ok, reject_data, []} = Builder.reject(followed, follow_activity)
	{:ok, reject, _meta} = ActivityPub.persist(reject_data, local: true)

	%{user: user, followed: followed, reject: reject}
	end

	test "", %{user: user, followed: followed, reject: reject} do
	assert User.following?(user, followed)
	assert Pleroma.FollowingRelationship.get(user, followed)

	{:ok, _, _} = SideEffects.handle(reject)

	refute User.following?(user, followed)
	refute Pleroma.FollowingRelationship.get(user, followed)
	assert User.get_follow_state(user, followed) == nil
	assert User.get_follow_state(user, followed, nil) == nil
	end
	end

	describe "removing a follower from remote" do
	setup do
	user = insert(:user)
	followed = insert(:user, local: false)

	# Mock a local-to-remote follow
	{:ok, follow_data, []} = Builder.follow(user, followed)

	follow_data =
	follow_data
	\|> Map.put("state", "accept")

	{:ok, follow, _meta} = ActivityPub.persist(follow_data, local: true)
	{:ok, _, _} = SideEffects.handle(follow)

	# Mock a remote-to-local accept
	{:ok, accept_data, _} = Builder.accept(followed, follow)
	{:ok, accept, _} = ActivityPub.persist(accept_data, local: false)
	{:ok, _, _} = SideEffects.handle(accept)

	# Mock a remote-to-local reject
	{:ok, reject_data, []} = Builder.reject(followed, follow)
	{:ok, reject, _meta} = ActivityPub.persist(reject_data, local: false)

	%{user: user, followed: followed, reject: reject}
	end

	test "", %{user: user, followed: followed, reject: reject} do
	assert User.following?(user, followed)
	assert Pleroma.FollowingRelationship.get(user, followed)

	{:ok, _, _} = SideEffects.handle(reject)

	refute User.following?(user, followed)
	refute Pleroma.FollowingRelationship.get(user, followed)

	assert Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, followed).data["state"] ==
	"reject"

	assert User.get_follow_state(user, followed) == nil
	assert User.get_follow_state(user, followed, nil) == nil
	end
	end

	describe "Group actors" do
	setup do
	poster =
	insert(:user,
	local: false,
	nickname: "poster@example.com",
	ap_id: "https://example.com/users/poster"
	)

	group = insert(:user, actor_type: "Group")

	make_create = fn mentioned_users ->
	mentions = mentioned_users \|> Enum.map(fn u -> "@#{u.nickname}" end) \|> Enum.join(" ")
	{:ok, draft} = ActivityDraft.create(poster, %{status: "#{mentions} hey"})

	create_activity_data =
	- Utils.make_create_data(draft.changes \|> Map.put(:published, nil), %{})
	+ draft.changes
	\|> put_in(["object", "id"], "https://example.com/object")
	\|> put_in(["id"], "https://example.com/activity")

	assert Enum.all?(mentioned_users, fn u -> u.ap_id in create_activity_data["to"] end)

	create_activity_data
	end

	%{poster: poster, group: group, make_create: make_create}
	end

	test "group should boost it", %{make_create: make_create, group: group} do
	create_activity_data = make_create.([group])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity,
	local: false,
	object_data: create_activity_data["object"]
	)

	object = Object.normalize(create_activity, fetch: false)
	assert [announce] = get_announces_of_object(object)
	assert announce.actor == group.ap_id
	end

	test "remote group should not boost it", %{make_create: make_create, group: group} do
	remote_group =
	insert(:user, actor_type: "Group", local: false, nickname: "remotegroup@example.com")

	create_activity_data = make_create.([group, remote_group])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity,
	local: false,
	object_data: create_activity_data["object"]
	)

	object = Object.normalize(create_activity, fetch: false)
	assert [announce] = get_announces_of_object(object)
	assert announce.actor == group.ap_id
	end

	test "group should not boost it if group is blocking poster", %{
	make_create: make_create,
	group: group,
	poster: poster
	} do
	{:ok, _} = CommonAPI.block(poster, group)
	create_activity_data = make_create.([group])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity,
	local: false,
	object_data: create_activity_data["object"]
	)

	object = Object.normalize(create_activity, fetch: false)
	assert [] = get_announces_of_object(object)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs
	index 2a4e78cf0..bb820267f 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs
	@@ -1,192 +1,192 @@
	# 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.QuestionHandlingTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

	test "Mastodon Question activity" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Jason.decode!()

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity, fetch: false)

	assert object.data["url"] == "https://mastodon.sdf.org/@rinpatch/102070944809637304"

	assert object.data["closed"] == "2019-05-11T09:03:36Z"

	assert object.data["context"] == activity.data["context"]

	assert object.data["context"] ==
	"tag:mastodon.sdf.org,2019-05-10:objectId=15095122:objectType=Conversation"

	assert object.data["anyOf"] == []

	assert Enum.sort(object.data["oneOf"]) ==
	Enum.sort([
	%{
	"name" => "25 char limit is dumb",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Dunno",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Everyone knows that!",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "I can't even fit a funny",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	}
	])

	user = insert(:user)

	{:ok, reply_activity} = CommonAPI.post(user, %{status: "hewwo", in_reply_to_id: activity.id})

	reply_object = Object.normalize(reply_activity, fetch: false)

	assert reply_object.data["context"] == object.data["context"]
	end

	test "Mastodon Question activity with HTML tags in plaintext" do
	options = [
	%{
	"type" => "Note",
	"name" => "<input type=\"date\">",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\"/>",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\" />",
	"replies" => %{"totalItems" => 1, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\"></input>",
	"replies" => %{"totalItems" => 1, "type" => "Collection"}
	}
	]

	data =
	File.read!("test/fixtures/mastodon-question-activity.json")
	\|> Jason.decode!()
	\|> Kernel.put_in(["object", "oneOf"], options)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(activity, fetch: false)

	assert Enum.sort(object.data["oneOf"]) == Enum.sort(options)
	end

	test "Mastodon Question activity with custom emojis" do
	options = [
	%{
	"type" => "Note",
	"name" => ":blobcat:",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => ":blobfox:",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	}
	]

	tag = [
	%{
	"icon" => %{
	"type" => "Image",
	"url" => "https://blob.cat/emoji/custom/blobcats/blobcat.png"
	},
	"id" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	"name" => ":blobcat:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	},
	%{
	"icon" => %{"type" => "Image", "url" => "https://blob.cat/emoji/blobfox/blobfox.png"},
	"id" => "https://blob.cat/emoji/blobfox/blobfox.png",
	"name" => ":blobfox:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]

	data =
	File.read!("test/fixtures/mastodon-question-activity.json")
	\|> Jason.decode!()
	\|> Kernel.put_in(["object", "oneOf"], options)
	\|> Kernel.put_in(["object", "tag"], tag)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(activity, fetch: false)

	assert object.data["oneOf"] == options

	assert object.data["emoji"] == %{
	"blobcat" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	"blobfox" => "https://blob.cat/emoji/blobfox/blobfox.png"
	}
	end

	test "returns same activity if received a second time" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Jason.decode!()

	- assert {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	+ assert {:ok, %Activity{local: false, id: id}} = Transmogrifier.handle_incoming(data)

	- assert {:ok, ^activity} = Transmogrifier.handle_incoming(data)
	+ assert {:ok, %Activity{id: ^id}} = Transmogrifier.handle_incoming(data)
	end

	test "accepts a Question with no content" do
	data =
	File.read!("test/fixtures/mastodon-question-activity.json")
	\|> Jason.decode!()
	\|> Kernel.put_in(["object", "content"], "")

	assert {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
	end

	test "it displays voters count for a poll" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "???",
	poll: %{expires_in: 10, options: ["yes", "no"]}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, _, _} = CommonAPI.vote(object, other_user, [1])

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	refute Map.has_key?(modified["object"], "voters")
	assert modified["object"]["votersCount"] == 1
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index bedb466a4..b921439d2 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,1156 +1,1156 @@
	# 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.TransmogrifierTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

	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 unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})
	object = Object.normalize(activity, fetch: false)

	note_obj = %{
	"type" => "Note",
	"id" => activity.object.data["id"],
	"content" => "test post",
	"published" => object.data["published"],
	"actor" => AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	}

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, activity.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	assert activity.data["object"] == [user.ap_id, note_obj]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it rejects Flag activities when both reporter and reported account are remote" do
	reporter = insert(:user, local: false, domain: "mastodon.cat")
	reported = insert(:user, local: false, domain: "nicecrew.digital")

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => reporter.ap_id,
	"content" => "blocked AND reported!!!",
	"object" => [reported.ap_id, "https://nicecrew.digital/objects/report-status"],
	"type" => "Flag"
	}

	assert {:reject, reason} = Transmogrifier.handle_incoming(message)
	assert reason =~ "third-party report"
	refute "Flag" \|> Pleroma.Activity.Queries.by_type() \|> Pleroma.Repo.one()
	end

	test "it accepts Flag activities with just actor id as object" do
	user = insert(:user)
	other_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => user.ap_id,
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it accepts Move activities" do
	old_user = insert(:user)
	new_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Move",
	"actor" => old_user.ap_id,
	"object" => old_user.ap_id,
	"target" => new_user.ap_id
	}

	assert :error = Transmogrifier.handle_incoming(message)

	{:ok, _new_user} = User.update_and_set_cache(new_user, %{also_known_as: [old_user.ap_id]})

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(message)
	assert activity.actor == old_user.ap_id
	assert activity.data["actor"] == old_user.ap_id
	assert activity.data["object"] == old_user.ap_id
	assert activity.data["target"] == new_user.ap_id
	assert activity.data["type"] == "Move"
	end

	test "it fixes both the Create and object contexts in a reply" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")
	insert(:user, ap_id: "https://p.helene.moe/users/helene")

	create_activity =
	"test/fixtures/create-pleroma-reply-to-misskey-thread.json"
	\|> File.read!()
	\|> Jason.decode!()

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(create_activity)

	object = Object.normalize(activity, fetch: false)

	assert activity.data["context"] == object.data["context"]
	end

	test "it fixes the public scope addressing" do
	insert(:user,
	ap_id: "https://mymath.rocks/endpoints/SYn3cl_N4HAPfPHgo2x37XunLEmhV9LnxCggcYwyec0"
	)

	object =
	"test/fixtures/bovine-bogus-public-note.json"
	\|> File.read!()
	\|> Jason.decode!()

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => "https://mymath.rocks/endpoints/SYn3cl_N4HAPfPHgo2x37XunLEmhV9LnxCggcYwyec0",
	"object" => object
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	object = Object.normalize(activity, fetch: false)
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in object.data["to"]
	end

	test "it keeps link tags" do
	insert(:user, ap_id: "https://example.org/users/alice")

	message = File.read!("test/fixtures/fep-e232.json") \|> Jason.decode!()

	assert capture_log(fn ->
	assert {:ok, activity} = Transmogrifier.handle_incoming(message)
	object = Object.normalize(activity)
	assert [%{"type" => "Mention"}, %{"type" => "Link"}] = object.data["tag"]
	end) =~ "Object rejected while fetching"
	end

	test "it accepts quote posts" do
	insert(:user, ap_id: "https://misskey.io/users/7rkrarq81i")

	object = File.read!("test/fixtures/quote_post/misskey_quote_post.json") \|> Jason.decode!()

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => "https://misskey.io/users/7rkrarq81i",
	"object" => object
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	# Object was created in the database
	object = Object.normalize(activity)
	assert object.data["quoteUrl"] == "https://misskey.io/notes/8vs6wxufd0"

	# It fetched the quoted post
	assert Object.normalize("https://misskey.io/notes/8vs6wxufd0")
	end

	test "doesn't allow remote edits to fake local likes" do
	# as a spot check for no internal fields getting injected
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	local_user = insert(:user)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => [local_user.ap_id]
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0
	end

	test "strips internal fields from history items in edited notes" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	local_user = insert(:user)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => [],
	"like_count" => 0
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [
	Map.merge(create_data["object"], %{
	"likes" => [local_user.ap_id],
	"like_count" => 1,
	"pleroma" => %{"internal_field" => "should_be_stripped"}
	})
	]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	# Check that internal fields are stripped from history items
	history_item = List.first(object.data["formerRepresentations"]["orderedItems"])
	assert history_item["likes"] == []
	assert history_item["like_count"] == 0
	refute Map.has_key?(history_item, "pleroma")
	end

	test "doesn't trip over remote likes in notes" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => %{
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097/likes",
	"totalItems" => 0,
	"type" => "Collection"
	}
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "likes", "totalItems"], 666)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	# in the future this should retain remote likes, but for now:
	assert object.data["like_count"] == 0
	end

	test "doesn't trip over remote likes in polls" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Question",
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "vote!",
	"anyOf" => [
	%{
	"type" => "Note",
	"name" => "a",
	"replies" => %{
	"type" => "Collection",
	"totalItems" => 3
	}
	},
	%{
	"type" => "Note",
	"name" => "b",
	"replies" => %{
	"type" => "Collection",
	"totalItems" => 1
	}
	}
	],
	"likes" => %{
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073/likes",
	"totalItems" => 0,
	"type" => "Collection"
	}
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "vote now!")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "likes", "totalItems"], 666)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "vote!"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "vote now!"
	assert object.data["likes"] == []
	# in the future this should retain remote likes, but for now:
	assert object.data["like_count"] == 0
	end
	end

	describe "prepare outgoing" do
	test "it inlines private announced objects" do
	user = insert(:user)

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

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)

	{:ok, modified} = Transmogrifier.prepare_activity(announce_activity.data)

	assert modified["object"]["content"] == "hey"
	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})

	with_mock Pleroma.Notification,
	get_notified_from_activity: fn _, _ -> [] end do
	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	refute called(Pleroma.Notification.get_notified_from_activity(:_, :_))
	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert modified["@context"] == Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

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

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "#2hu :firefox:",
	generator: %{type: "Application", name: "TestClient", url: "https://pleroma.social"}
	})

	# Ensure injected application data made it into the activity
	# as we don't have a Token to derive it from, otherwise it will
	# be nil and the test will pass
	assert %{
	- type: "Application",
	- name: "TestClient",
	- url: "https://pleroma.social"
	+ "type" => "Application",
	+ "name" => "TestClient",
	+ "url" => "https://pleroma.social"
	} == activity.object.data["generator"]

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["generator"])
	assert is_nil(modified["object"]["rules"])
	assert is_nil(modified["object"]["language"])
	assert is_nil(modified["object"]["voters"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["likes"])
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} = CommonAPI.post(user, %{status: "@#{other_user.nickname} :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} :moominmamma:",
	visibility: "direct"
	})

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create(%{title: "foo"}, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert is_nil(modified["bcc"])
	end

	test "it can handle Listen activities" do
	listen_activity = insert(:listen)

	# This has an inlined object as in ObjectView
	{:ok, modified} = Transmogrifier.prepare_activity(listen_activity.data)

	assert modified["type"] == "Listen"

	user = insert(:user)

	{:ok, activity} = CommonAPI.listen(user, %{"title" => "lain radio episode 1"})

	user_ap_id = user.ap_id
	activity_ap_id = activity.data["id"]
	activity_to = activity.data["to"]
	activity_cc = activity.data["cc"]
	object_ap_id = activity.data["object"]
	object_type = activity.object.data["type"]

	# This does not have an inlined object
	{:ok, modified2} = Transmogrifier.prepare_activity(activity.data)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "Listen",
	"actor" => ^user_ap_id,
	"to" => ^activity_to,
	"cc" => ^activity_cc,
	"context" => "http://localhost" <> _,
	"id" => ^activity_ap_id,
	"object" => %{
	"actor" => ^user_ap_id,
	"attributedTo" => ^user_ap_id,
	"id" => ^object_ap_id,
	"type" => ^object_type,
	"to" => ^activity_to,
	"cc" => ^activity_cc
	}
	},
	modified2
	)
	end

	test "custom emoji urls are URI encoded" do
	# :dinosaur: filename has a space -> dino walking.gif
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})

	{:ok, prepared} = Transmogrifier.prepare_activity(activity.data)

	assert length(prepared["object"]["tag"]) == 1

	url = prepared["object"]["tag"] \|> List.first() \|> Map.get("icon") \|> Map.get("url")

	assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	end

	test "Updates of Notes are handled" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})
	{:ok, update} = CommonAPI.update(activity, user, %{status: "mew mew :blank:"})

	{:ok, prepared} = Transmogrifier.prepare_activity(update.data)

	assert %{
	"content" => "mew mew :blank:",
	"tag" => [%{"name" => ":blank:", "type" => "Emoji"}],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"content" => "everybody do the dinosaur :dinosaur:",
	"tag" => [%{"name" => ":dinosaur:", "type" => "Emoji"}]
	}
	]
	}
	} = prepared["object"]
	end

	test "Updates of Actors are handled" do
	user = insert(:user, local: true)

	changeset = User.update_changeset(user, %{name: "new name"})
	{:ok, unpersisted_user} = Ecto.Changeset.apply_action(changeset, :update)

	updated_object =
	UserView.render("user.json", user: unpersisted_user)
	\|> Map.delete("@context")

	{:ok, update_data, []} = Builder.update(user, updated_object)

	{:ok, activity, _} =
	Pipeline.common_pipeline(update_data,
	local: true,
	user_update_changeset: changeset
	)

	assert {:ok, prepared} = Transmogrifier.prepare_activity(activity.data)
	assert prepared["type"] == "Update"
	assert prepared["@context"]
	assert prepared["object"]["type"] == user.actor_type
	end

	test "Correctly handles Undo activities" do
	blocked = insert(:user)
	blocker = insert(:user, local: true)

	blocked_ap_id = blocked.ap_id
	blocker_ap_id = blocker.ap_id

	{:ok, %Activity{} = block_activity} = CommonAPI.block(blocked, blocker)
	{:ok, %Activity{} = undo_activity} = CommonAPI.unblock(blocked, blocker)
	{:ok, data} = Transmogrifier.prepare_activity(undo_activity.data)

	block_ap_id = block_activity.data["id"]
	assert is_binary(block_ap_id)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "Undo",
	"id" => "http://localhost" <> _,
	"actor" => ^blocker_ap_id,
	"object" => ^block_ap_id,
	"to" => [^blocked_ap_id],
	"cc" => [],
	"bto" => [],
	"bcc" => []
	},
	data
	)
	end

	test "Correctly handles EmojiReact activities" do
	user = insert(:user, local: true)
	note_activity = insert(:note_activity)

	user_ap_id = user.ap_id
	user_followers = user.follower_address
	note_author = note_activity.data["actor"]
	note_ap_id = note_activity.data["object"]

	assert is_binary(note_author)
	assert is_binary(note_ap_id)

	{:ok, react_activity} = CommonAPI.react_with_emoji(note_activity.id, user, "🐈")
	{:ok, data} = Transmogrifier.prepare_activity(react_activity.data)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "EmojiReact",
	"actor" => ^user_ap_id,
	"to" => [^user_followers, ^note_author],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"bto" => [],
	"bcc" => [],
	"content" => "🐈",
	"context" => "2hu",
	"id" => "http://localhost" <> _,
	"object" => ^note_ap_id,
	"tag" => []
	},
	data
	)
	end

	test "EmojiReact custom emoji urls are URI encoded" do
	user = insert(:user, local: true)
	note_activity = insert(:note_activity)

	{:ok, react_activity} = CommonAPI.react_with_emoji(note_activity.id, user, ":dinosaur:")
	{:ok, data} = Transmogrifier.prepare_activity(react_activity.data)

	assert length(data["tag"]) == 1

	tag = List.first(data["tag"])
	url = tag["icon"]["url"]

	assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	assert tag["id"] == "http://localhost:4001/emoji/dino%20walking.gif"
	end

	test "it prepares a quote post" do
	user = insert(:user)

	{:ok, quoted_post} = CommonAPI.post(user, %{status: "hey"})
	{:ok, quote_post} = CommonAPI.post(user, %{status: "hey", quoted_status_id: quoted_post.id})

	{:ok, modified} = Transmogrifier.prepare_activity(quote_post.data)

	%{data: %{"id" => quote_id}} = Object.normalize(quoted_post)

	assert modified["object"]["quoteUrl"] == quote_id
	assert modified["object"]["quoteUri"] == quote_id
	end

	test "it adds language of the object to its json-ld context" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	{:ok, modified} = Transmogrifier.prepare_activity(activity.object.data)

	assert [_, _, %{"@language" => "pl"}] = modified["@context"]
	end

	test "it adds language of the object to Create activity json-ld context" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	{:ok, modified} = Transmogrifier.prepare_activity(activity.data)

	assert [_, _, %{"@language" => "pl"}] = modified["@context"]
	end

	test "it strips report data" do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, reported_activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	object_ap_id = reported_activity.object.data["id"]

	assert {:ok, activity} =
	Pleroma.Web.ActivityPub.ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	{:ok, data} = Transmogrifier.prepare_activity(activity.data)

	expected_data =
	activity.data
	\|> put_in(["object"], [target_account.ap_id, object_ap_id])
	\|> Map.put("actor", reporter.ap_id)
	\|> Map.merge(Utils.make_json_ld_header())

	assert data == expected_data
	end

	test "it strips report data and anonymize" do
	placeholder = insert(:user)

	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, reported_activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	object_ap_id = reported_activity.object.data["id"]

	assert {:ok, activity} =
	Pleroma.Web.ActivityPub.ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	{:ok, data} = Transmogrifier.prepare_activity(activity.data)

	expected_data =
	activity.data
	\|> put_in(["object"], [target_account.ap_id, object_ap_id])
	\|> Map.put("actor", placeholder.ap_id)
	\|> Map.merge(Utils.make_json_ld_header())

	assert data == expected_data
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end

	describe "fix_summary/1" do
	test "returns fixed object" do
	assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
	assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
	assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
	end
	end

	describe "fix_url/1" do
	test "fixes data for object when url is map" do
	object = %{
	"url" => %{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	}

	assert Transmogrifier.fix_url(object) == %{
	"url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	end

	test "returns non-modified object" do
	assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
	end
	end

	describe "get_obj_helper/2" do
	test "returns nil when cannot normalize object" do
	assert capture_log(fn ->
	refute Transmogrifier.get_obj_helper("test-obj-id")
	end) =~ "Unsupported URI scheme"
	end

	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)
	end
	end

	describe "fix_attachments/1" do
	test "puts dimensions into attachment url field" do
	object = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960,
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	expected = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpeg",
	"href" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960
	}
	],
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	assert Transmogrifier.fix_attachments(object) == expected
	end
	end

	describe "prepare_object/1" do
	test "it processes history" do
	original = %{
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)

	history_item = Enum.at(processed["formerRepresentations"]["orderedItems"], 0)

	refute Map.has_key?(history_item, "generator")

	assert [%{"name" => ":blobcat:"}] = history_item["tag"]
	end

	test "it works when there is no or bad history" do
	original = %{
	"formerRepresentations" => %{
	"items" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)
	assert processed["formerRepresentations"] == original["formerRepresentations"]
	end

	test "it uses contentMap to specify post language" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	object = Transmogrifier.prepare_object(activity.object.data)

	assert %{"contentMap" => %{"pl" => "Cześć"}} = object
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
	index fc578d828..afc7cb39c 100644
	--- a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
	@@ -1,1217 +1,1217 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Swoosh.TestAssertions

	alias Pleroma.Activity
	alias Pleroma.MFA
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

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

	:ok
	end

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	user = insert(:user)

	conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")

	assert json_response(conn, 200)
	end

	test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, 200)
	end

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_tags])

	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	admin: admin,
	user1: user1,
	user2: user2
	} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
	"#{user2.nickname}&tags[]=foo&tags[]=bar"
	)

	assert empty_json_response(conn)
	assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]

	log_entry = Repo.one(ModerationLog)

	users =
	[user1.nickname, user2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["foo", "bar"] \|> Enum.join(", ")

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} added tags: #{tags} to users: #{users}"
	end

	test "it does not modify tags of not specified users", %{
	conn: conn,
	user1: user1,
	user2: user2,
	user3: user3
	} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
	"#{user2.nickname}&tags[]=foo&tags[]=bar"
	)

	assert empty_json_response(conn)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end

	test "it requires privileged role :users_manage_tags", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put("/api/pleroma/admin/users/tag?nicknames[]=nickname&tags[]=foo&tags[]=bar")

	assert json_response(response, :forbidden)
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_tags])
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	admin: admin,
	user1: user1,
	user2: user2
	} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
	"#{user2.nickname}&tags[]=x&tags[]=z"
	)

	assert empty_json_response(conn)
	assert User.get_cached_by_id(user1.id).tags == []
	assert User.get_cached_by_id(user2.id).tags == ["y"]

	log_entry = Repo.one(ModerationLog)

	users =
	[user1.nickname, user2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["x", "z"] \|> Enum.join(", ")

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} removed tags: #{tags} from users: #{users}"
	end

	test "it does not modify tags of not specified users", %{
	conn: conn,
	user1: user1,
	user2: user2,
	user3: user3
	} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
	"#{user2.nickname}&tags[]=x&tags[]=z"
	)

	assert empty_json_response(conn)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end

	test "it requires privileged role :users_manage_tags", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/tag?nicknames[]=nickname&tags[]=foo&tags[]=bar")

	assert json_response(response, :forbidden)
	end
	end

	describe "/api/pleroma/admin/users/:nickname/permission_group" do
	test "GET is giving user_info", %{admin: admin, conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group", %{admin: admin, conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{user.nickname} admin"
	end

	test "/:right POST, can add to a permission group (multiple)", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	assert json_response(conn, 200) == %{"is_admin" => true}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{user_one.nickname}, @#{user_two.nickname} admin"
	end

	test "/:right DELETE, can remove from a permission group", %{admin: admin, conn: conn} do
	user = insert(:user, is_admin: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{"is_admin" => false}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} revoked admin role from @#{user.nickname}"
	end

	test "/:right DELETE, can remove from a permission group (multiple)", %{
	admin: admin,
	conn: conn
	} do
	user_one = insert(:user, is_admin: true)
	user_two = insert(:user, is_admin: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	assert json_response(conn, 200) == %{"is_admin" => false}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} revoked admin role from @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "/:right DELETE, admin cannot revoke their own admin status (single)", %{
	admin: admin,
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/#{admin.nickname}/permission_group/admin")

	assert json_response(conn, 403) == %{"error" => "You can't revoke your own admin status."}
	end

	test "/:right DELETE, admin cannot revoke their own admin status (multiple)", %{
	admin: admin,
	conn: conn
	} do
	user = insert(:user, is_admin: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [admin.nickname, user.nickname]
	})

	assert json_response(conn, 403) == %{
	"error" => "You can't revoke your own admin/moderator status."
	}
	end
	end

	describe "/api/pleroma/admin/users/:nickname/password_reset" do
	test "it returns a password reset link", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])

	user = insert(:user)

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

	resp = json_response(conn, 200)

	assert Regex.match?(~r/(http:\/\/\|https:\/\/)/, resp["link"])
	end

	test "it requires privileged role :users_manage_credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/nickname/password_reset")

	assert json_response(response, :forbidden)
	end
	end

	describe "PUT disable_mfa" do
	test "returns 200 and disable 2fa", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: "otp_secret", confirmed: true}
	}
	)

	response =
	conn
	\|> put("/api/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
	\|> json_response(200)

	assert response == user.nickname
	mfa_settings = refresh_record(user).multi_factor_authentication_settings

	refute mfa_settings.enabled
	refute mfa_settings.totp.confirmed
	end

	test "returns 404 if user not found", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])

	response =
	conn
	\|> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
	\|> json_response(404)

	assert response == %{"error" => "Not found"}
	end

	test "it requires privileged role :users_manage_credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})

	assert json_response(response, :forbidden)
	end
	end

	describe "GET /api/pleroma/admin/restart" do
	setup do: clear_config(:configurable_from_database, true)

	test "pleroma restarts", %{conn: conn} do
	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) == %{}
	end) =~ "pleroma restarted"

	refute Restarter.Pleroma.need_reboot?()
	end
	end

	test "need_reboot flag", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/admin/need_reboot")
	\|> json_response(200) == %{"need_reboot" => false}

	Restarter.Pleroma.need_reboot()

	assert conn
	\|> get("/api/pleroma/admin/need_reboot")
	\|> json_response(200) == %{"need_reboot" => true}

	on_exit(fn -> Restarter.Pleroma.refresh() end)
	end

	describe "GET /api/pleroma/admin/users/:nickname/statuses" do
	setup do
	clear_config([:instance, :admin_privileges], [:messages_read])

	user = insert(:user)

	insert(:note_activity, user: user)
	insert(:note_activity, user: user)
	insert(:note_activity, user: user)

	%{user: user}
	end

	test "renders user's statuses", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert %{"total" => 3, "activities" => activities} = json_response(conn, 200)
	assert length(activities) == 3
	end

	test "it requires privileged role :messages_read", %{conn: conn, user: user} do
	clear_config([:instance, :admin_privileges], [])

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, :forbidden)
	end

	test "renders user's statuses with pagination", %{conn: conn, user: user} do
	%{"total" => 3, "activities" => [activity1]} =
	conn
	\|> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=1")
	\|> json_response(200)

	%{"total" => 3, "activities" => [activity2]} =
	conn
	\|> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=2")
	\|> json_response(200)

	refute activity1 == activity2
	end

	test "doesn't return private statuses by default", %{conn: conn, user: user} do
	{:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	{:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})

	%{"total" => 4, "activities" => activities} =
	conn
	\|> get("/api/pleroma/admin/users/#{user.nickname}/statuses")
	\|> json_response(200)

	assert length(activities) == 4
	end

	test "returns private statuses with godmode on", %{conn: conn, user: user} do
	{:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	{:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})

	%{"total" => 5, "activities" => activities} =
	conn
	\|> get("/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
	\|> json_response(200)

	assert length(activities) == 5
	end

	test "excludes reblogs by default", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})
	{:ok, %Activity{}} = CommonAPI.repeat(activity.id, other_user)

	assert %{"total" => 0, "activities" => []} ==
	conn
	\|> get("/api/pleroma/admin/users/#{other_user.nickname}/statuses")
	\|> json_response(200)

	assert %{"total" => 1, "activities" => [_]} =
	conn
	\|> get(
	"/api/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true"
	)
	\|> json_response(200)
	end
	end

	describe "GET /api/pleroma/admin/users/:nickname/chats" do
	setup do
	clear_config([:instance, :admin_privileges], [:messages_read])

	user = insert(:user)

	%{user: user}
	end

	test "renders user's chats", %{conn: conn, user: user} do
	recipients = insert_list(3, :user)

	Enum.each(recipients, fn recipient ->
	CommonAPI.post_chat_message(user, recipient, "yo")
	end)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/chats")

	assert json_response(conn, 200) \|> length() == 3
	end

	test "it requires privileged role :messages_read", %{conn: conn, user: user} do
	clear_config([:instance, :admin_privileges], [])

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/chats")

	assert json_response(conn, :forbidden)
	end
	end

	describe "GET /api/pleroma/admin/users/:nickname/chats unauthorized" do
	setup do
	user = insert(:user)
	recipient = insert(:user)
	CommonAPI.post_chat_message(user, recipient, "yo")
	%{conn: conn} = oauth_access(["read:chats"])
	%{conn: conn, user: user}
	end

	test "returns 403", %{conn: conn, user: user} do
	conn
	\|> get("/api/pleroma/admin/users/#{user.nickname}/chats")
	\|> json_response(403)
	end
	end

	describe "GET /api/pleroma/admin/users/:nickname/chats unauthenticated" do
	setup do
	user = insert(:user)
	recipient = insert(:user)
	CommonAPI.post_chat_message(user, recipient, "yo")
	%{conn: build_conn(), user: user}
	end

	test "returns 403", %{conn: conn, user: user} do
	conn
	\|> get("/api/pleroma/admin/users/#{user.nickname}/chats")
	\|> json_response(403)
	end
	end

	describe "GET /api/pleroma/admin/moderation_log" do
	setup do
	clear_config([:instance, :admin_privileges], [:moderation_log_read])
	moderator = insert(:user, is_moderator: true)

	%{moderator: moderator}
	end

	test "returns the log", %{conn: conn, admin: admin} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
	})

	conn = get(conn, "/api/pleroma/admin/moderation_log")

	response = json_response(conn, 200)
	[first_entry, second_entry] = response["items"]

	assert response["total"] == 2
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"

	assert second_entry["data"]["action"] == "relay_follow"

	assert second_entry["message"] ==
	"@#{admin.nickname} followed relay: https://example.org/relay"
	end

	test "returns the log with pagination", %{conn: conn, admin: admin} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 2
	assert response1["items"] \|> length() == 1
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"

	conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")

	response2 = json_response(conn2, 200)
	[second_entry] = response2["items"]

	assert response2["total"] == 2
	assert response2["items"] \|> length() == 1
	assert second_entry["data"]["action"] == "relay_follow"

	assert second_entry["message"] ==
	"@#{admin.nickname} followed relay: https://example.org/relay"
	end

	test "filters log by date", %{conn: conn, admin: admin} do
	first_date = "2017-08-15T15:47:06Z"
	second_date = "2017-08-20T15:47:06Z"

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.from_iso8601!(first_date)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.from_iso8601!(second_date)
	})

	conn1 =
	get(
	conn,
	"/api/pleroma/admin/moderation_log?start_date=#{second_date}"
	)

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"
	end

	test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	}
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => moderator.id,
	"nickname" => moderator.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	}
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1
	assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
	end

	test "returns log filtered by search", %{conn: conn, moderator: moderator} do
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_follow",
	target: "https://example.org/relay"
	})

	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_unfollow",
	target: "https://example.org/relay"
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1

	assert get_in(first_entry, ["data", "message"]) ==
	"@#{moderator.nickname} unfollowed relay: https://example.org/relay"
	end

	test "it requires privileged role :moderation_log_read", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	assert conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> get("/api/pleroma/admin/moderation_log")
	\|> json_response(:forbidden)
	end
	end

	test "gets a remote users when [:instance, :limit_to_local_content] is set to :unauthenticated",
	%{conn: conn} do
	clear_config(Pleroma.Config.get([:instance, :limit_to_local_content]), :unauthenticated)
	user = insert(:user, %{local: false, nickname: "u@peer1.com"})
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")

	assert json_response(conn, 200)
	end

	describe "GET /users/:nickname/credentials" do
	test "gets the user credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])
	user = insert(:user)
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")

	response = assert json_response(conn, 200)
	assert response["email"] == user.email
	end

	test "returns 403 if requested by a non-admin" do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/pleroma/admin/users/#{user.nickname}/credentials")

	assert json_response(conn, :forbidden)
	end

	test "it requires privileged role :users_manage_credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> get("/api/pleroma/admin/users/nickname/credentials")

	assert json_response(response, :forbidden)
	end
	end

	describe "PATCH /users/:nickname/credentials" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "changes password and email", %{conn: conn, admin: admin, user: user} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])

	assert user.password_reset_pending == false

	conn =
	patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"password" => "new_password",
	"email" => "new_email@example.com",
	"name" => "new_name"
	})

	assert json_response(conn, 200) == %{"status" => "success"}

	ObanHelpers.perform_all()

	updated_user = User.get_by_id(user.id)

	assert updated_user.email == "new_email@example.com"
	assert updated_user.name == "new_name"
	assert updated_user.password_hash != user.password_hash
	assert updated_user.password_reset_pending == true

	[log_entry2, log_entry1] = ModerationLog \|> Repo.all() \|> Enum.sort()

	assert ModerationLog.get_log_entry_message(log_entry1) ==
	"@#{admin.nickname} updated users: @#{user.nickname}"

	assert ModerationLog.get_log_entry_message(log_entry2) ==
	"@#{admin.nickname} forced password reset for users: @#{user.nickname}"
	end

	test "returns 403 if requested by a non-admin", %{user: user} do
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"password" => "new_password",
	"email" => "new_email@example.com",
	"name" => "new_name"
	})

	assert json_response(conn, :forbidden)
	end

	test "returns 403 if not privileged with :users_manage_credentials", %{conn: conn, user: user} do
	clear_config([:instance, :admin_privileges], [])

	conn =
	patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"password" => "new_password",
	"email" => "new_email@example.com",
	"name" => "new_name"
	})

	assert json_response(conn, :forbidden)
	end

	test "changes actor type from permitted list", %{conn: conn, user: user} do
	assert user.actor_type == "Person"

	assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"actor_type" => "Service"
	})
	\|> json_response(200) == %{"status" => "success"}

	updated_user = User.get_by_id(user.id)

	assert updated_user.actor_type == "Service"

	assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"actor_type" => "Application"
	})
	\|> json_response(400) == %{"errors" => %{"actor_type" => "is invalid"}}
	end

	test "update non existing user", %{conn: conn} do
	assert patch(conn, "/api/pleroma/admin/users/non-existing/credentials", %{
	"password" => "new_password"
	})
	\|> json_response(404) == %{"error" => "Not found"}
	end
	end

	describe "PATCH /users/:nickname/force_password_reset" do
	test "sets password_reset_pending to true", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])
	user = insert(:user)
	assert user.password_reset_pending == false

	conn =
	patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})

	assert empty_json_response(conn) == ""

	ObanHelpers.perform_all()

	assert User.get_by_id(user.id).password_reset_pending == true
	end

	test "it requires privileged role :users_manage_credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> patch("/api/pleroma/admin/users/force_password_reset", %{nickname: "nickname"})

	assert json_response(response, :forbidden)
	end
	end

	describe "PATCH /confirm_email" do
	test "it confirms emails of two users", %{conn: conn, admin: admin} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])
	[first_user, second_user] = insert_pair(:user, is_confirmed: false)

	refute first_user.is_confirmed
	refute second_user.is_confirmed

	ret_conn =
	patch(conn, "/api/pleroma/admin/users/confirm_email", %{
	nicknames: [
	first_user.nickname,
	second_user.nickname
	]
	})

	assert ret_conn.status == 200

	first_user = User.get_by_id(first_user.id)
	second_user = User.get_by_id(second_user.id)

	assert first_user.is_confirmed
	assert second_user.is_confirmed

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{second_user.nickname}"
	end

	test "it requires privileged role :users_manage_credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> patch("/api/pleroma/admin/users/confirm_email", %{nicknames: ["nickname"]})

	assert json_response(response, :forbidden)
	end
	end

	describe "PATCH /resend_confirmation_email" do
	test "it resend emails for two users", %{conn: conn, admin: admin} do
	clear_config([:instance, :admin_privileges], [:users_manage_credentials])
	[first_user, second_user] = insert_pair(:user, is_confirmed: false)

	ret_conn =
	patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
	nicknames: [
	first_user.nickname,
	second_user.nickname
	]
	})

	assert ret_conn.status == 200

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{second_user.nickname}"

	ObanHelpers.perform_all()

	Pleroma.Emails.UserEmail.account_confirmation_email(first_user)
	# temporary hackney fix until hackney max_connections bug is fixed
	# https://git.pleroma.social/pleroma/pleroma/-/issues/2101
	\|> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
	\|> assert_email_sent()
	end

	test "it requires privileged role :users_manage_credentials", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> patch("/api/pleroma/admin/users/resend_confirmation_email", %{nicknames: ["nickname"]})

	assert json_response(response, :forbidden)
	end
	end

	describe "/api/pleroma/admin/stats" do
	setup do
	clear_config([:instance, :admin_privileges], [:statistics_read])
	end

	test "status visibility count", %{conn: conn} do
	user = insert(:user)
	CommonAPI.post(user, %{visibility: "public", status: "hey"})
	CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
	CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})

	response =
	conn
	\|> get("/api/pleroma/admin/stats")
	\|> json_response(200)

	assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
	response["status_visibility"]
	end

	test "by instance", %{conn: conn} do
	user1 = insert(:user)
	instance2 = "instance2.tld"
	user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})

	CommonAPI.post(user1, %{visibility: "public", status: "hey"})
	- CommonAPI.post(user2, %{visibility: "unlisted", status: "hey"})
	- CommonAPI.post(user2, %{visibility: "private", status: "hey"})
	+ post_as_remote(user2, %{visibility: "unlisted", status: "hey"})
	+ post_as_remote(user2, %{visibility: "private", status: "hey"})

	response =
	conn
	\|> get("/api/pleroma/admin/stats", instance: instance2)
	\|> json_response(200)

	assert %{"direct" => 0, "private" => 1, "public" => 0, "unlisted" => 1} =
	response["status_visibility"]
	end

	test "it requires privileged role :statistics_read", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	assert conn
	\|> get("/api/pleroma/admin/stats", instance: "lain.wired")
	\|> json_response(:forbidden)
	end
	end

	describe "/api/pleroma/backups" do
	test "it creates a backup", %{conn: conn} do
	ConfigMock
	\|> Mox.stub_with(Pleroma.Config)

	admin = %{id: admin_id, nickname: admin_nickname} = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = %{id: user_id, nickname: user_nickname} = insert(:user)

	assert "" ==
	conn
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
	\|> json_response(200)

	assert [backup] = Repo.all(Pleroma.User.Backup)

	ObanHelpers.perform_all()

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert String.contains?(
	email.html_body,
	"A full backup of your Pleroma account was requested"
	)

	assert_email_sent(to: {user.name, user.email}, html_body: email.html_body)

	log_message = "@#{admin_nickname} requested account backup for @#{user_nickname}"

	assert [
	%{
	data: %{
	"action" => "create_backup",
	"actor" => %{
	"id" => ^admin_id,
	"nickname" => ^admin_nickname
	},
	"message" => ^log_message,
	"subject" => %{
	"id" => ^user_id,
	"nickname" => ^user_nickname
	}
	}
	}
	] = Pleroma.ModerationLog \|> Repo.all()
	end

	test "it doesn't limit admins", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user)

	assert "" ==
	conn
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
	\|> json_response(200)

	assert [_backup] = Repo.all(Pleroma.User.Backup)

	assert "" ==
	conn
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
	\|> json_response(200)

	assert Repo.aggregate(Pleroma.User.Backup, :count) == 2
	end
	end

	describe "POST /api/v1/pleroma/admin/reload_emoji" do
	setup do
	clear_config([:instance, :admin_privileges], [:emoji_manage_emoji])

	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{conn: conn, admin: admin}}
	end

	test "it requires privileged role :emoji_manage_emoji", %{conn: conn} do
	assert conn
	\|> post("/api/v1/pleroma/admin/reload_emoji")
	\|> json_response(200)

	clear_config([:instance, :admin_privileges], [])

	assert conn
	\|> post("/api/v1/pleroma/admin/reload_emoji")
	\|> json_response(:forbidden)
	end
	end
	end

	# Needed for testing
	defmodule Pleroma.Web.Endpoint.NotReal do
	end

	defmodule Pleroma.Captcha.NotReal do
	end
	diff --git a/test/pleroma/web/common_api_test.exs b/test/pleroma/web/common_api_test.exs
	index 5d0ad4572..c02240847 100644
	--- a/test/pleroma/web/common_api_test.exs
	+++ b/test/pleroma/web/common_api_test.exs
	@@ -1,2267 +1,2346 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Rule
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.PollWorker

	import Ecto.Query, only: [from: 2, where: 3]
	import Mock
	import Mox
	import Pleroma.Factory

	require Pleroma.Activity.Queries
	require Pleroma.Constants

	defp get_announces_of_object(%{data: %{"id" => id}} = _object) do
	Pleroma.Activity.Queries.by_type("Announce")
	\|> Pleroma.Activity.Queries.by_object_id(id)
	\|> Pleroma.Repo.all()
	end

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

	setup do
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	describe "posting polls" do
	test "it posts a poll" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "who is the best",
	poll: %{expires_in: 600, options: ["reimu", "marisa"]}
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["type"] == "Question"
	assert object.data["oneOf"] \|> length() == 2

	assert_enqueued(
	worker: PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: NaiveDateTime.from_iso8601!(object.data["closed"])
	)
	end
	end

	describe "blocking" do
	setup do
	blocker = insert(:user)
	blocked = insert(:user, local: false)
	CommonAPI.follow(blocked, blocker)
	CommonAPI.follow(blocker, blocked)
	CommonAPI.accept_follow_request(blocker, blocked)
	CommonAPI.accept_follow_request(blocked, blocked)
	%{blocker: blocker, blocked: blocked}
	end

	test "it blocks and federates", %{blocker: blocker, blocked: blocked} do
	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert User.get_follow_state(blocker, blocked) == :follow_accept
	refute is_nil(Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked))

	assert {:ok, block} = CommonAPI.block(blocked, blocker)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute User.get_follow_state(blocker, blocked)

	assert %{data: %{"state" => "reject"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked)

	assert called(Pleroma.Web.Federator.publish(block))
	end
	end

	test "add expiring block", %{blocker: blocker, blocked: blocked} do
	{:ok, _} = CommonAPI.block(blocked, blocker, %{expires_in: 60})
	assert User.blocks?(blocker, blocked)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unblock_user", "blocker_id" => blocker.id, "blocked_id" => blocked.id}

	assert :ok = perform_job(worker, args)
	refute User.blocks?(blocker, blocked)
	end

	test "it blocks and does not federate if outgoing blocks are disabled", %{
	blocker: blocker,
	blocked: blocked
	} do
	clear_config([:instance, :federating], true)
	clear_config([:activitypub, :outgoing_blocks], false)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, block} = CommonAPI.block(blocked, blocker)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute called(Pleroma.Web.Federator.publish(block))
	end
	end
	end

	describe "posting chat messages" do
	setup do: clear_config([:instance, :chat_limit])

	test "it posts a self-chat" do
	author = insert(:user)
	recipient = author

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"remember to buy milk when milk truk arive"
	)

	assert activity.data["type"] == "Create"
	end

	test "it posts a chat message without content but with an attachment" do
	author = insert(:user)
	recipient = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: author.ap_id)

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ ->
	nil
	end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	nil,
	media_id: upload.id
	)

	notification =
	Notification.for_user_and_activity(recipient, activity)
	\|> Repo.preload(:activity)

	- assert called(Pleroma.Web.Push.send(notification))
	- assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	+ assert called(Pleroma.Web.Push.send(:meck.is(&(&1.id == notification.id))))
	+
	+ assert called(
	+ Pleroma.Web.Streamer.stream(
	+ ["user", "user:notification"],
	+ :meck.is(&(&1.id == notification.id))
	+ )
	+ )
	+
	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	assert activity
	end
	end

	test "it adds html newlines" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"uguu\nuguuu"
	)

	assert other_user.ap_id not in activity.recipients

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == "uguu<br/>uguuu"
	end

	test "it linkifies" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"https://example.org is the site of @#{other_user.nickname} #2hu"
	)

	assert other_user.ap_id not in activity.recipients

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] ==
	"<a href=\"https://example.org\" rel=\"ugc\">https://example.org</a> is the site of <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{other_user.id}\" href=\"#{other_user.ap_id}\" rel=\"ugc\">@<span>#{other_user.nickname}</span></a></span> <a class=\"hashtag\" data-tag=\"2hu\" href=\"http://localhost:4001/tag/2hu\">#2hu</a>"
	end

	test "it posts a chat message" do
	author = insert(:user)
	recipient = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"a test message <script>alert('uuu')</script> :firefox:"
	)

	assert activity.data["type"] == "Create"
	assert activity.local
	object = Object.normalize(activity, fetch: false)

	assert object.data["type"] == "ChatMessage"
	assert object.data["to"] == [recipient.ap_id]

	assert object.data["content"] ==
	"a test message <script>alert('uuu')</script> :firefox:"

	assert object.data["emoji"] == %{
	"firefox" => "http://localhost:4001/emoji/Firefox.gif"
	}

	assert Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)

	assert :ok == Pleroma.Web.Federator.perform(:publish, activity)
	end

	test "it reject messages over the local limit" do
	clear_config([:instance, :chat_limit], 2)

	author = insert(:user)
	recipient = insert(:user)

	{:error, message} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"123"
	)

	assert message == :content_too_long
	end

	test "it reject messages via MRF" do
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	author = insert(:user)
	recipient = insert(:user)

	assert {:reject, "[KeywordPolicy] Matches with rejected keyword"} ==
	CommonAPI.post_chat_message(author, recipient, "GNO/Linux")
	end

	test "it reject messages with attachments not belonging to user" do
	author = insert(:user)
	not_author = insert(:user)
	recipient = author

	attachment = insert(:attachment, %{user: not_author})

	{:error, message} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"123",
	media_id: attachment.id
	)

	assert message == :forbidden
	end
	end

	describe "unblocking" do
	test "it works even without an existing block activity" do
	blocked = insert(:user)
	blocker = insert(:user)
	User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	assert {:ok, :no_activity} == CommonAPI.unblock(blocked, blocker)
	refute User.blocks?(blocker, blocked)
	end
	end

	describe "deletion" do
	test "it works with pruned objects" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	Object.normalize(post, fetch: false)
	\|> Object.prune()

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows users to delete their posts" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it does not allow a user to delete posts from another user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
	assert Activity.get_by_id(post.id)
	end

	test "it allows privileged users to delete other user's posts" do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "it doesn't allow unprivileged mods or admins to delete other user's posts" do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true, is_admin: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, moderator)
	assert Activity.get_by_id(post.id)
	end

	test "privileged users deleting non-local posts won't federate the delete" do
	clear_config([:instance, :admin_privileges], [:messages_delete])
	# This is the user of the ingested activity
	_user =
	insert(:user,
	local: false,
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: NaiveDateTime.utc_now()
	)

	admin = insert(:user, is_admin: true)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	{:ok, post} = Transmogrifier.handle_incoming(data)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, admin)
	assert delete.local
	refute called(Pleroma.Web.Federator.publish(:_))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows privileged users to delete banned user's posts" do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
	User.set_activation(user, false)

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end
	end

	test "favoriting race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.favorite(activity.id, user)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.favorite(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 20
	end

	test "repeating race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.repeat(activity.id, user)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.repeat(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 20
	end

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})

	assert Visibility.direct?(convo_reply)

	assert activity.data["context"] == convo_reply.data["context"]
	end

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey",
	visibility: "direct"
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "I don't really like @#{tridi.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

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

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	visibility: "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})

	object = Object.normalize(activity, fetch: false)

	- assert Object.tags(object) == ["2hu"]
	+ assert Object.hashtags(object) == ["2hu"]
	+ assert [%{"type" => "Hashtag", "name" => "#2hu"}, "2hu"] = Object.tags(object)
	end

	test "zwnj is treated as word character" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#ساٴين‌س"})

	object = Object.normalize(activity, fetch: false)

	- assert Object.tags(object) == ["ساٴين‌س"]
	+ assert Object.hashtags(object) == ["ساٴين‌س"]
	end

	test "allows lang attribute" do
	user = insert(:user)
	text = ~s{<span lang="en">something</span><p lang="diaetuitech_rpyhpgc">random</p>}

	{:ok, activity} = CommonAPI.post(user, %{status: text, content_type: "text/html"})

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == text
	end

	test "double dot in link is allowed" do
	user = insert(:user)
	text = "https://example.to/something..mp3"
	{:ok, activity} = CommonAPI.post(user, %{status: text})

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == "<a href=\"#{text}\" rel=\"ugc\">#{text}</a>"
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})

	assert Object.normalize(activity, fetch: false).data["emoji"]["firefox"]
	end

	+ describe "posting through the pipeline" do
	+ test "it streams out the activity only after the transaction" do
	+ user = insert(:user)
	+
	+ Pleroma.Web.ActivityPub.ActivityPubMock
	+ \|> expect(:stream_out, fn %Activity{data: %{"type" => "Create"}} -> nil end)
	+
	+ assert {:ok, %Activity{object: %Object{}}} = CommonAPI.post(user, %{status: "hey"})
	+ end
	+
	+ test "it addresses direct messages without mentions to the author" do
	+ user = insert(:user)
	+
	+ {:ok, activity} = CommonAPI.post(user, %{status: "note to self", visibility: "direct"})
	+ object = Object.normalize(activity, fetch: false)
	+
	+ assert activity.data["to"] == []
	+ assert activity.data["cc"] == [user.ap_id]
	+ assert object.data["cc"] == [user.ap_id]
	+ assert activity.data["directMessage"] == true
	+ assert Visibility.get_visibility(object) == "direct"
	+ assert activity.recipients == [user.ap_id]
	+ end
	+
	+ test "it keeps the application and list information of local posts" do
	+ user = insert(:user)
	+ {:ok, list} = Pleroma.List.create(%{title: "foo"}, user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "for the list",
	+ visibility: "list:#{list.id}",
	+ generator: %{
	+ "type" => "Application",
	+ "name" => "PleromaFE",
	+ "url" => "https://pleroma.social"
	+ }
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ assert activity.data["listMessage"] == list.ap_id
	+ assert activity.data["bcc"] == [list.ap_id]
	+ assert object.data["listMessage"] == list.ap_id
	+ assert object.data["generator"]["name"] == "PleromaFE"
	+ assert list.ap_id in activity.recipients
	+ end
	+
	+ test "it returns a preview without persisting anything" do
	+ user = insert(:user)
	+
	+ assert {:ok, %Activity{id: "pleroma:fakeid"} = activity} =
	+ CommonAPI.post(user, %{status: "preview me", preview: true})
	+
	+ assert activity.data["object"]["content"] == "preview me"
	+ assert Repo.aggregate(Activity, :count, :id) == 0
	+ assert Repo.aggregate(Object, :count, :id) == 0
	+ end
	+
	+ test "it returns MRF rejections and pipeline errors in the legacy shape" do
	+ clear_config([:mrf_keyword, :reject], ["GNO"])
	+ clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
	+ user = insert(:user)
	+
	+ assert {:error, {:reject, "[KeywordPolicy] Matches with rejected keyword"}} =
	+ CommonAPI.post(user, %{status: "GNO is not unix"})
	+
	+ clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)
	+
	+ assert {:error, :expired_activities_disabled} =
	+ CommonAPI.post(user, %{status: "gone soon", expires_in: 100_000})
	+ end
	+ end
	+
	describe "posting" do
	test "it adds an emoji on an external site" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey :external_emoji:"})

	assert %{"external_emoji" => url} = Object.normalize(activity).data["emoji"]
	assert url == "https://example.com/emoji.png"

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

	assert %{"blank" => url} = Object.normalize(activity).data["emoji"]
	assert url == "#{Pleroma.Web.Endpoint.url()}/emoji/blank.png"
	end

	test "it copies emoji from the subject of the parent post" do
	%Object{} =
	object =
	Object.normalize("https://patch.cx/objects/a399c28e-c821-4820-bc3e-4afeb044c16f",
	fetch: true
	)

	activity = Activity.get_create_by_object_ap_id(object.data["id"])
	user = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(user, %{
	in_reply_to_id: activity.id,
	status: ":joker_disapprove:",
	spoiler_text: ":joker_smile:"
	})

	assert Object.normalize(reply_activity).data["emoji"]["joker_smile"]
	refute Object.normalize(reply_activity).data["emoji"]["joker_disapprove"]
	end

	test "deactivated users can't post" do
	user = insert(:user, is_active: false)
	assert {:error, _} = CommonAPI.post(user, %{status: "ye"})
	end

	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	to: [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/html"
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	assert object.data["source"]["content"] == post
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/markdown"
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == "<p><b>2hu</b></p>"
	assert object.data["source"]["content"] == post
	end

	test "it renders MFM posts and marks their ActivityPub representation" do
	user = insert(:user)

	post = "<p class='scrub-this'>$[spin.speed=1s 13:37]</p>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/x.misskeymarkdown"
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["htmlMfm"] == true

	assert object.data["source"] == %{
	"content" => post,
	"mediaType" => "text/x.misskeymarkdown"
	}

	assert object.data["content"] =~ ~s(class="mfm-spin")
	assert object.data["content"] =~ ~s(data-mfm-speed="1s")
	assert object.data["content"] =~ "13:37"
	refute object.data["content"] =~ "scrub-this"
	end

	test "it falls back safely for malformed MFM" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "$[spin malformed",
	content_type: "text/x.misskeymarkdown"
	})

	object = Object.normalize(activity, fetch: false)

	refute object.data["content"] =~ ~s(class="mfm-spin")
	assert object.data["content"] =~ "malformed"
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: visibility,
	in_reply_to_status_id: activity.id
	})
	end)
	end

	test "replying with a direct message will NOT auto-add the author of the reply to the recipient list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "I'm stupid"})

	{:ok, open_answer} =
	CommonAPI.post(other_user, %{status: "No ur smart", in_reply_to_status_id: post.id})

	# The OP is implicitly added
	assert user.ap_id in open_answer.recipients

	{:ok, secret_answer} =
	CommonAPI.post(other_user, %{
	status: "lol, that guy really is stupid, right, @#{third_user.nickname}?",
	in_reply_to_status_id: post.id,
	visibility: "direct"
	})

	assert third_user.ap_id in secret_answer.recipients

	# The OP is not added
	refute user.ap_id in secret_answer.recipients
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create(%{title: "foo"}, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	assert activity.data["bcc"] == [list.ap_id]
	- assert activity.recipients == [list.ap_id, user.ap_id]
	+ assert Enum.sort(activity.recipients) == Enum.sort([list.ap_id, user.ap_id])
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{status: ""})
	end

	test "it validates character limits are correctly enforced" do
	clear_config([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{status: "foobar"})

	assert {:ok, _activity} = CommonAPI.post(user, %{status: "12345"})
	end

	test "it validates media attachment limits are correctly enforced" do
	clear_config([:instance, :max_media_attachments], 4)

	user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)

	assert {:error, "Too many attachments"} =
	CommonAPI.post(user, %{
	status: "",
	media_ids: List.duplicate(upload.id, 5)
	})

	assert {:ok, _activity} =
	CommonAPI.post(user, %{
	status: "",
	media_ids: [upload.id]
	})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)

	assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at: expires_at
	)
	end

	test "it allows quote posting" do
	user = insert(:user)

	{:ok, quoted} = CommonAPI.post(user, %{status: "Hello world"})

	{:ok, quote_post} =
	CommonAPI.post(user, %{status: "nice post", quoted_status_id: quoted.id})

	quoted = Object.normalize(quoted)
	quote_post = Object.normalize(quote_post)

	assert quote_post.data["quoteUrl"] == quoted.data["id"]

	# The OP is not mentioned
	refute quoted.data["actor"] in quote_post.data["to"]
	end

	test "it supports fallback from `quote_id`" do
	user = insert(:user)

	{:ok, quoted} = CommonAPI.post(user, %{status: "Hello world"})
	{:ok, quote_post} = CommonAPI.post(user, %{status: "nice post", quote_id: quoted.id})

	quoted = Object.normalize(quoted)
	quote_post = Object.normalize(quote_post)

	assert quote_post.data["quoteUrl"] == quoted.data["id"]
	end

	test "quote posting with explicit addressing doesn't mention the OP" do
	user = insert(:user)

	{:ok, quoted} = CommonAPI.post(user, %{status: "Hello world"})

	{:ok, quote_post} =
	CommonAPI.post(user, %{status: "nice post", quoted_status_id: quoted.id, to: []})

	assert Object.normalize(quote_post).data["to"] == [Pleroma.Constants.as_public()]
	end

	test "quote posting visibility" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, direct} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
	{:ok, private} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	{:ok, unlisted} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
	{:ok, local} = CommonAPI.post(user, %{status: ".", visibility: "local"})
	{:ok, public} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:error, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: direct.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: private.id})
	{:error, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: private.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: unlisted.id})
	{:ok, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: unlisted.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: local.id})
	{:ok, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: local.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: public.id})
	{:ok, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: public.id})
	end

	test "it properly mentions punycode domain" do
	user = insert(:user)

	_mentioned_user =
	insert(:user, ap_id: "https://xn--i2raa.com/users/yyy", nickname: "yyy@xn--i2raa.com")

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey @yyy@xn--i2raa.com", content_type: "text/markdown"})

	assert "https://xn--i2raa.com/users/yyy" in Object.normalize(activity).data["to"]
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

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

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	assert unreaction.local

	# On federation, it contains the undone (and deleted) object
	unreaction_with_object = %{
	unreaction
	\| data: Map.put(unreaction.data, "object", reaction.data)
	}

	assert called(Pleroma.Web.Federator.publish(unreaction_with_object))
	end
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, user)
	assert Visibility.public?(announce_activity)
	end

	test "can't repeat a repeat" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, other_user)

	refute match?({:ok, %Activity{}}, CommonAPI.repeat(announce.id, user))
	end

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} =
	CommonAPI.repeat(activity.id, user, %{visibility: "private"})

	assert Visibility.private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)
	end

	test "author can repeat own private statuses" do
	author = insert(:user)
	follower = insert(:user)
	CommonAPI.follow(author, follower)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, author)

	assert Visibility.private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)

	assert Visibility.visible_for_user?(activity, follower)
	assert {:error, :not_found} = CommonAPI.repeat(activity.id, follower)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post_activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{data: data}} = CommonAPI.favorite(post_activity.id, user)
	assert data["type"] == "Like"
	assert data["actor"] == user.ap_id
	assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, user)
	{:ok, ^announce} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{}} = CommonAPI.favorite(activity.id, user)
	assert {:ok, :already_liked} = CommonAPI.favorite(activity.id, user)
	end
	end

	describe "pinned statuses" do
	setup do
	clear_config([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "activity not found error", %{user: user} do
	assert {:error, :not_found} = CommonAPI.pin("id", user)
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)
	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How is fediverse today?",
	poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)

	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, :ownership_error} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity_two.id, user)
	end

	test "only public can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "private status", visibility: "private"})
	{:error, :non_public_error} = CommonAPI.pin(activity.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	id = activity.id

	assert match?({:ok, %{id: ^id}}, CommonAPI.unpin(activity.id, user))

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, _} = CommonAPI.delete(activity.id, user)

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "ephemeral activity won't be deleted if was pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "Hello!", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)
	refute Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	user = refresh_record(user)
	{:ok, _} = CommonAPI.unpin(activity.id, user)

	# recreates expiration job on unpin
	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)
	end

	test "ephemeral activity deletion job won't be deleted on pinning error", %{
	user: user,
	activity: activity
	} do
	clear_config([:instance, :max_pinned_statuses], 1)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)

	{:ok, activity2} = CommonAPI.post(user, %{status: "another status", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)

	user = refresh_record(user)
	{:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity2.id, user)

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "marks notifications as read after mute" do
	author = insert(:user)
	activity = insert(:note_activity, user: author)

	friend1 = insert(:user)
	friend2 = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(
	friend2,
	%{
	status: "@#{author.nickname} @#{friend1.nickname} test reply",
	in_reply_to_status_id: activity.id
	}
	)

	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, friend2)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, friend1)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	unread_notifications =
	Repo.all(from(n in Notification, where: n.seen == false, where: n.user_id == ^author.id))

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)

	{:ok, _} = CommonAPI.add_mute(activity, author)
	assert CommonAPI.thread_muted?(activity, author)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	read_notifications =
	Repo.all(from(n in Notification, where: n.seen == true, where: n.user_id == ^author.id))

	assert Enum.any?(read_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(activity, user)
	assert CommonAPI.thread_muted?(activity, user)
	end

	test "add expiring mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(activity, user, %{expires_in: 60})
	assert CommonAPI.thread_muted?(activity, user)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_conversation", "user_id" => user.id, "activity_id" => activity.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)
	refute CommonAPI.thread_muted?(activity, user)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(activity, user)
	{:ok, _} = CommonAPI.remove_mute(activity, user)
	refute CommonAPI.thread_muted?(activity, user)
	end

	test "remove mute by ids", %{user: user, activity: activity} do
	CommonAPI.add_mute(activity, user)
	{:ok, _} = CommonAPI.remove_mute(activity.id, user.id)
	refute CommonAPI.thread_muted?(activity, user)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(activity, user)
	{:error, _} = CommonAPI.add_mute(activity, user)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
	activity = Activity.normalize(activity)

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	reported_object_ap_id = activity.object.data["id"]
	comment = "foobar"

	report_data = %{
	account_id: target_user.id,
	comment: comment,
	status_ids: [activity.id]
	}

	note_obj = %{
	"type" => "Note",
	"id" => reported_object_ap_id,
	"content" => "foobar",
	"published" => activity.object.data["published"],
	"actor" => AccountView.render("show.json", %{user: target_user})
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "doesn't create a report when post is not visible to user" do
	reporter = insert(:user)
	target_user = insert(:user)
	{:ok, post} = CommonAPI.post(target_user, %{status: "Eric", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, reporter)

	# Fails when all status are invisible
	report_data = %{
	account_id: target_user.id,
	comment: "foobar",
	status_ids: [post.id]
	}

	assert {:error, :visibility_error} = CommonAPI.report(reporter, report_data)
	end

	test "doesn't create a report when some posts are not visible to user" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, visible_activity} = CommonAPI.post(target_user, %{status: "cofe"})

	{:ok, invisibile_activity} =
	CommonAPI.post(target_user, %{status: "cawfee", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(invisibile_activity)
	assert Pleroma.Web.ActivityPub.Visibility.public?(visible_activity)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(invisibile_activity, reporter)

	# Fails when some statuses are invisible
	report_data_partial = %{
	account_id: target_user.id,
	comment: "foobar",
	status_ids: [visible_activity.id, invisibile_activity.id]
	}

	assert {:error, :visibility_error} = CommonAPI.report(reporter, report_data_partial)
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)
	object = Object.normalize(activity)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, object_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert object_id == object.data["id"]
	end

	test "updates report state, don't strip when report_strip_status is false" do
	clear_config([:instance, :report_strip_status], false)

	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id, data: report_data}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, reported_activity] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert is_map(reported_activity)

	assert reported_activity["content"] ==
	report_data["object"] \|> Enum.at(1) \|> Map.get("content")
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel very offended!",
	status_ids: [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end

	test "creates a report with provided rules" do
	reporter = insert(:user)
	target_user = insert(:user)

	%{id: rule_id} = Rule.create(%{text: "There are no rules"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id

	report_data = %{
	account_id: target_user.id,
	rule_ids: [rule_id]
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"object" => [^target_ap_id],
	"state" => "open",
	"rules" => [^rule_id]
	}
	} = flag_activity
	end

	test "assigns report to an account" do
	[reporter, target_user] = insert_pair(:user)
	%{id: assigned} = insert(:user)

	{:ok, %Activity{id: report_id}} = CommonAPI.report(reporter, %{account_id: target_user.id})

	{:ok, activity} = CommonAPI.assign_report_to_account(report_id, assigned)

	assert %{data: %{"assigned_account" => ^assigned}} = activity
	end

	test "unassigns report from account" do
	[reporter, target_user] = insert_pair(:user)
	%{id: assigned} = insert(:user)

	{:ok, %Activity{id: report_id}} = CommonAPI.report(reporter, %{account_id: target_user.id})

	CommonAPI.assign_report_to_account(report_id, assigned)
	{:ok, activity} = CommonAPI.assign_report_to_account(report_id, nil)

	refute Map.has_key?(activity.data, "assigned_account")
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muted, muter)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muted, muter)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muted, muter)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "follow/2" do
	test "directly follows a non-locked local user" do
	[follower, followed] = insert_pair(:user)
	{:ok, followed, follower, _} = CommonAPI.follow(followed, follower)

	assert User.following?(follower, followed)
	end
	end

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, followed, follower, _} = CommonAPI.follow(followed, follower)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(followed, follower)

	refute User.subscribed_to?(follower, followed)
	end

	test "also unpins a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, followed, follower, _} = CommonAPI.follow(followed, follower)
	{:ok, _endorsement} = User.endorse(follower, followed)

	assert User.endorses?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(followed, follower)

	refute User.endorses?(follower, followed)
	end

	test "cancels a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	assert {:ok, followed, follower, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(followed, follower)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(followed, follower)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true, local: false)

	assert {:ok, followed, follower, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(followed, follower)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(followed, follower)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_three} = CommonAPI.follow(user, follower_two)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_three} = CommonAPI.follow(user, follower_two)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "doesn't create a following relationship if the corresponding follow request doesn't exist" do
	user = insert(:user, is_locked: true)
	not_follower = insert(:user)
	CommonAPI.accept_follow_request(not_follower, user)

	assert Pleroma.FollowingRelationship.following?(not_follower, user) == false
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

	object = Object.normalize(activity, fetch: false)

	{:ok, _, object} = CommonAPI.vote(object, other_user, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(object, other_user, [1])
	end
	end

	describe "listen/2" do
	test "returns a valid activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "public"
	end

	test "respects visibility=private" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000,
	visibility: "private"
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end

	describe "get_user/1" do
	test "gets user by ap_id" do
	user = insert(:user)
	assert CommonAPI.get_user(user.ap_id) == user
	end

	test "gets user by guessed nickname" do
	user = insert(:user, ap_id: "", nickname: "mario@mushroom.kingdom")
	assert CommonAPI.get_user("https://mushroom.kingdom/users/mario") == user
	end

	test "fallback" do
	assert %User{
	name: "",
	ap_id: "",
	nickname: "erroruser@example.com"
	} = CommonAPI.get_user("")
	end
	end

	describe "with `local` visibility" do
	setup do: clear_config([:instance, :federating], true)

	test "post" do
	user = insert(:user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	assert Visibility.local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "delete" do
	user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"deleted_activity_id" => ^activity_id}} = activity} =
	CommonAPI.delete(activity_id, user)

	assert Visibility.local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "repeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Announce"}} = activity} =
	CommonAPI.repeat(activity_id, user)

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unrepeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	assert {:ok, _} = CommonAPI.repeat(activity_id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unrepeat(activity_id, user)

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "favorite" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Like"}} = activity} =
	CommonAPI.favorite(activity.id, user)

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unfavorite" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{}} = CommonAPI.favorite(activity.id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, activity} = CommonAPI.unfavorite(activity.id, user)
	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "react_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "EmojiReact"}} = activity} =
	CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unreact_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, _reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end

	describe "update/3" do
	test "updates a post" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1"})

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end

	test "does not change visibility" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1", visibility: "private"})

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Visibility.get_visibility(updated_object) == "private"
	assert Visibility.get_visibility(updated) == "private"
	end

	test "updates a post with emoji" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2 :#{emoji2}:"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated_object.data["emoji"]
	end

	test "updates a post with emoji and federate properly" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _p -> nil end do
	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2 :#{emoji2}:"})

	assert updated.data["object"]["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated.data["object"]["emoji"]

	assert called(Pleroma.Web.Federator.publish(updated))
	end
	end

	test "editing a post that copied a remote title with remote emoji should keep that emoji" do
	remote_emoji_uri = "https://remote.org/emoji.png"

	note =
	insert(
	:note,
	data: %{
	"summary" => ":remoteemoji:",
	"emoji" => %{
	"remoteemoji" => remote_emoji_uri
	},
	"tag" => [
	%{
	"type" => "Emoji",
	"name" => "remoteemoji",
	"icon" => %{"url" => remote_emoji_uri}
	}
	]
	}
	)

	note_activity = insert(:note_activity, note: note)

	user = insert(:user)

	{:ok, reply} =
	CommonAPI.post(user, %{
	status: "reply",
	spoiler_text: ":remoteemoji:",
	in_reply_to_id: note_activity.id
	})

	assert reply.object.data["emoji"]["remoteemoji"] == remote_emoji_uri

	{:ok, edit} =
	CommonAPI.update(reply, user, %{status: "reply mew mew", spoiler_text: ":remoteemoji:"})

	edited_note = Pleroma.Object.normalize(edit)

	assert edited_note.data["emoji"]["remoteemoji"] == remote_emoji_uri
	end

	test "respects MRF" do
	user = insert(:user)

	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
	clear_config([:mrf_keyword, :replace], [{"updated", "mewmew"}])

	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "updated 1"})
	assert Object.normalize(activity).data["summary"] == "mewmew 1"

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "mewmew 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end
	end

	describe "Group actors" do
	setup do
	poster = insert(:user)
	group = insert(:user, actor_type: "Group")
	other_group = insert(:user, actor_type: "Group")
	%{poster: poster, group: group, other_group: other_group}
	end

	test "it boosts public posts", %{poster: poster, group: group} do
	{:ok, post} = CommonAPI.post(poster, %{status: "hey @#{group.nickname}"})

	announces = get_announces_of_object(post.object)
	assert [_] = announces
	end

	test "it does not boost private posts", %{poster: poster, group: group} do
	{:ok, private_post} =
	CommonAPI.post(poster, %{status: "hey @#{group.nickname}", visibility: "private"})

	assert [] = get_announces_of_object(private_post.object)
	end

	test "remote groups do not boost any posts", %{poster: poster} do
	remote_group =
	insert(:user, actor_type: "Group", local: false, nickname: "remote@example.com")

	{:ok, post} = CommonAPI.post(poster, %{status: "hey @#{User.full_nickname(remote_group)}"})
	assert remote_group.ap_id in post.data["to"]

	announces = get_announces_of_object(post.object)
	assert [] = announces
	end

	test "multiple groups mentioned", %{poster: poster, group: group, other_group: other_group} do
	{:ok, post} =
	CommonAPI.post(poster, %{status: "hey @#{group.nickname} @#{other_group.nickname}"})

	announces = get_announces_of_object(post.object)
	assert [_, _] = announces
	end

	test "it does not boost if group is blocking poster", %{poster: poster, group: group} do
	{:ok, _} = CommonAPI.block(poster, group)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey @#{group.nickname}"})

	announces = get_announces_of_object(post.object)
	assert [] = announces
	end
	end

	describe "Oban jobs are cancelled" do
	setup do
	clear_config([:instance, :federating], true)

	local_user = insert(:user)

	remote_one =
	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	inbox: "https://domain.com/users/nick1/inbox",
	shared_inbox: "https://domain.com/inbox"
	})

	remote_two =
	insert(:user, %{
	local: false,
	nickname: "nick2@example.com",
	ap_id: "https://example.com/users/nick2",
	inbox: "https://example.com/users/nick2/inbox",
	shared_inbox: "https://example.com/inbox"
	})

	%{local_user: local_user, remote_one: remote_one, remote_two: remote_two}
	end

	test "when deleting posts", %{
	local_user: local_user,
	remote_one: remote_one,
	remote_two: remote_two
	} do
	{:ok, _, _} = Pleroma.User.follow(remote_one, local_user)
	{:ok, _, _} = Pleroma.User.follow(remote_two, local_user)

	{:ok, %{id: activity_id} = _activity} =
	CommonAPI.post(local_user, %{status: "Happy Friday everyone!"})

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^activity_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 2

	# The delete should have triggered cancelling the publish_one jobs
	assert {:ok, _delete} = CommonAPI.delete(activity_id, local_user)

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^activity_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 2
	end

	test "when unfavoriting posts", %{
	local_user: local_user,
	remote_one: remote_user
	} do
	- {:ok, activity} =
	- CommonAPI.post(remote_user, %{status: "I like turtles!"})
	+ activity = insert(:note_activity, user: remote_user)

	{:ok, %{id: favorite_id} = _favorite} =
	CommonAPI.favorite(activity.id, local_user)

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^favorite_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 1

	# The unfavorite should have triggered cancelling the publish_one jobs
	assert {:ok, _unfavorite} = CommonAPI.unfavorite(activity.id, local_user)

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^favorite_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 1
	end

	test "when unboosting posts", %{
	local_user: local_user,
	remote_one: remote_one,
	remote_two: remote_two
	} do
	{:ok, _, _} = Pleroma.User.follow(remote_one, local_user)
	{:ok, _, _} = Pleroma.User.follow(remote_two, local_user)

	- {:ok, activity} =
	- CommonAPI.post(remote_one, %{status: "This is an unpleasant post"})
	+ activity = insert(:note_activity, user: remote_one)

	{:ok, %{id: repeat_id} = _repeat} =
	CommonAPI.repeat(activity.id, local_user)

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^repeat_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 2

	# The unrepeat should have triggered cancelling the publish_one jobs
	assert {:ok, _unfavorite} = CommonAPI.unrepeat(activity.id, local_user)

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^repeat_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 2
	end

	test "when unreacting to posts", %{
	local_user: local_user,
	remote_one: remote_one,
	remote_two: remote_two
	} do
	{:ok, _, _} = Pleroma.User.follow(remote_one, local_user)
	{:ok, _, _} = Pleroma.User.follow(remote_two, local_user)

	- {:ok, %{id: activity_id}} =
	- CommonAPI.post(remote_one, %{status: "Gang gang!!!!"})
	+ %{id: activity_id} = insert(:note_activity, user: remote_one)

	{:ok, %{id: react_id} = _react} =
	CommonAPI.react_with_emoji(activity_id, local_user, "👍")

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^react_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 2

	# The unreact should have triggered cancelling the publish_one jobs
	assert {:ok, _unreact} = CommonAPI.unreact_with_emoji(activity_id, local_user, "👍")

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^react_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 2
	end
	end
	end
	diff --git a/test/pleroma/web/feed/user_controller_test.exs b/test/pleroma/web/feed/user_controller_test.exs
	index d12904ec0..92ae75996 100644
	--- a/test/pleroma/web/feed/user_controller_test.exs
	+++ b/test/pleroma/web/feed/user_controller_test.exs
	@@ -1,427 +1,427 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.UserControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:static_fe, :enabled], false)

	describe "feed" do
	setup do: clear_config([:feed])

	setup do
	clear_config(
	[:feed, :post_title],
	%{max_length: 15, omission: "..."}
	)

	activity = insert(:note_activity)

	note =
	insert(:note,
	data: %{
	"content" => "This & this is :moominmamma: note ",
	"source" => "This & this is :moominmamma: note ",
	"attachment" => [
	%{
	"url" => [
	%{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
	]
	}
	],
	"inReplyTo" => activity.data["id"],
	"context" => "2hu & as",
	"summary" => "2hu & as"
	}
	)

	note_activity = insert(:note_activity, note: note)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	note2 =
	insert(:note,
	user: user,
	data: %{
	"content" => "42 & This is :moominmamma: note ",
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity2 = insert(:note_activity, note: note2)

	note3 =
	insert(:note,
	user: user,
	data: %{
	"content" => "This note tests whether HTML entities are truncated properly",
	"summary" => "Won't, didn't fail",
	"inReplyTo" => note_activity2.id
	}
	)

	_note_activity3 = insert(:note_activity, note: note3)
	object = Object.normalize(note_activity, fetch: false)

	encoded_title = FeedView.activity_title(note3.data)

	[user: user, object: object, max_id: note_activity2.id, encoded_title: encoded_title]
	end

	test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	xml = SweetXml.parse(resp)
	activity_titles = SweetXml.xpath(xml, ~x"//entry/title/text()"l)

	assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert SweetXml.xpath(xml, ~x"//entry/link[@rel='self']/@href"sl) == []
	assert length(SweetXml.xpath(xml, ~x"//entry/link[@rel='alternate']/@href"sl)) == 3
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == [~c"2hu & as"]
	end

	test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == [~c"2hu & as"]
	end

	test "escapes query parameters in feed self links", %{conn: conn, user: user} do
	for format <- ~w[atom rss] do
	response =
	conn
	\|> get("/users/#{user.nickname}/feed.#{format}?first=one&second=two")
	\|> response(200)

	assert response =~ "first=one&second=two"
	refute response =~ "first=one&second=two"
	end
	end

	test "keeps fallback summary markup inert in rendered Atom content", %{
	conn: conn,
	object: object,
	user: user
	} do
	data =
	object.data
	\|> Map.put("content", "")
	\|> Map.put("summary", "<script>alert('feed')</script>")

	object
	\|> Ecto.Changeset.change(data: data)
	\|> Pleroma.Repo.update!()

	response =
	conn
	\|> get("/users/#{user.nickname}/feed.atom")
	\|> response(200)

	assert response =~
	"&lt;script&gt;alert(&#39;feed&#39;)&lt;/script&gt;"

	content_values = response \|> parse() \|> xpath(~x"//entry/content/text()"sl)

	assert Enum.any?(content_values, fn content ->
	String.starts_with?(content, "<script>alert('feed')</script>")
	end)
	end

	test "does not expose sensitive attachments as enclosures", %{
	conn: conn,
	object: object,
	user: user
	} do
	object
	\|> Ecto.Changeset.change(data: Map.put(object.data, "sensitive", true))
	\|> Pleroma.Repo.update!()

	atom_response =
	conn
	\|> get("/users/#{user.nickname}/feed.atom")
	\|> response(200)

	rss_response =
	conn
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)

	refute atom_response =~ "rel=\"enclosure\""
	refute rss_response =~ "<enclosure "
	end

	test "uses enclosure fallbacks for user feeds", %{conn: conn, object: object, user: user} do
	attachment = %{"url" => [%{"href" => "https://example.com/file.bin"}]}

	object
	\|> Ecto.Changeset.change(data: Map.put(object.data, "attachment", [attachment]))
	\|> Pleroma.Repo.update!()

	atom_xml =
	conn
	\|> get("/users/#{user.nickname}/feed.atom")
	\|> response(200)
	\|> parse()

	assert xpath(atom_xml, ~x"//entry/link[@rel='enclosure']/@href"sl) == [
	"https://example.com/file.bin"
	]

	assert xpath(atom_xml, ~x"//entry/link[@rel='enclosure']/@type"sl) == [
	"application/octet-stream"
	]

	assert xpath(atom_xml, ~x"//entry/link[@rel='enclosure']/@length"sl) == []

	rss_xml =
	conn
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)
	\|> parse()

	assert xpath(rss_xml, ~x"//item/enclosure/@url"sl) == []
	assert xpath(rss_xml, ~x"//item/media:content/@url"sl) == ["https://example.com/file.bin"]

	assert xpath(rss_xml, ~x"//item/media:content/@type"sl) == [
	"application/octet-stream"
	]
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, "nonexisting"))

	assert response(conn, 404)
	end

	test "returns noindex meta for missing user", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/users/nonexisting")

	assert html_response(conn, 200) =~ "<meta content=\"noindex, noarchive\" name=\"robots\">"
	end

	test "returns feed with public and unlisted activities", %{conn: conn} do
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "public", visibility: "public"})
	{:ok, _} = CommonAPI.post(user, %{status: "direct", visibility: "direct"})
	{:ok, _} = CommonAPI.post(user, %{status: "unlisted", visibility: "unlisted"})
	{:ok, _} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)
	\|> Enum.sort()

	assert activity_titles == [~c"public", ~c"unlisted"]
	end

	test "returns 404 when the user is remote", %{conn: conn} do
	user = insert(:user, local: false)

	- {:ok, _} = CommonAPI.post(user, %{status: "test"})
	+ {:ok, _} = post_as_remote(user, %{status: "test"})

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end

	test "does not require authentication on non-federating instances", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)
	end

	test "does not mangle HTML entities midway", %{
	conn: conn,
	user: user,
	object: object,
	encoded_title: encoded_title
	} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])
	assert resp =~ encoded_title
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "feed_redirect" do
	test "with html format, it redirects to user feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response ==
	Pleroma.Web.Fallback.RedirectController.redirector_with_meta(
	conn,
	%{user: user}
	).resp_body
	end

	test "with html format, it falls back to frontend when user is remote", %{conn: conn} do
	user = insert(:user, local: false)

	- {:ok, _} = CommonAPI.post(user, %{status: "test"})
	+ {:ok, _} = post_as_remote(user, %{status: "test"})

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response =~ "</html>"
	end

	test "with html format, it falls back to frontend when user is not found", %{conn: conn} do
	response =
	conn
	\|> get("/users/jimm")
	\|> response(200)

	assert response =~ "</html>"
	end

	test "with non-html / non-json format, it redirects to user feed in atom format", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

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

	assert conn.status == 302

	assert redirected_to(conn) ==
	"#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}/feed.atom"
	end

	test "redirects to rss feed when explicitly requested", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

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

	assert conn.status == 302

	assert redirected_to(conn) ==
	"#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}/feed.rss"
	end

	test "with non-html / non-json format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(user_feed_path(conn, :feed, "jimm"))
	\|> response(404)

	assert response == ~S({"error":"Not found"})
	end
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public])

	test "returns 404 for user feed", %{conn: conn} do
	clear_config([:instance, :public], false)
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "test"})

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
	index bed897e23..4200655d7 100644
	--- a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
	@@ -1,1125 +1,1125 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import Tesla.Mock

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "home" do
	setup do: oauth_access(["read:statuses"])

	test "does NOT embed account/pleroma/relationship in statuses", %{
	user: user,
	conn: conn
	} do
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert Enum.all?(response, fn n ->
	get_in(n, ["account", "pleroma", "relationship"]) == %{}
	end)
	end

	test "the home timeline when the direct messages are excluded", %{user: user, conn: conn} do
	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	conn = get(conn, "/api/v1/timelines/home?exclude_visibilities[]=direct")

	assert status_ids = json_response_and_validate_schema(conn, :ok) \|> Enum.map(& &1["id"])
	assert public_activity.id in status_ids
	assert unlisted_activity.id in status_ids
	assert private_activity.id in status_ids
	refute direct_activity.id in status_ids
	end

	test "muted emotions", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "filtering", %{conn: conn, user: user} do
	local_user = insert(:user)
	{:ok, user, local_user} = User.follow(user, local_user)
	{:ok, local_activity} = CommonAPI.post(local_user, %{status: "Status"})
	with_media = create_with_media_activity(local_user)

	remote_user = insert(:user, local: false)
	{:ok, _user, remote_user} = User.follow(user, remote_user)
	remote_activity = create_remote_activity(remote_user)

	without_filter_ids =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in without_filter_ids
	assert remote_activity.id in without_filter_ids
	assert with_media.id in without_filter_ids

	only_local_ids =
	conn
	\|> get("/api/v1/timelines/home?local=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in only_local_ids
	refute remote_activity.id in only_local_ids
	assert with_media.id in only_local_ids

	only_local_media_ids =
	conn
	\|> get("/api/v1/timelines/home?local=true&only_media=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in only_local_media_ids
	refute remote_activity.id in only_local_media_ids
	assert with_media.id in only_local_media_ids

	remote_ids =
	conn
	\|> get("/api/v1/timelines/home?remote=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in remote_ids
	assert remote_activity.id in remote_ids
	refute with_media.id in remote_ids

	assert conn
	\|> get("/api/v1/timelines/home?remote=true&only_media=true")
	\|> json_response_and_validate_schema(200) == []

	assert conn
	\|> get("/api/v1/timelines/home?remote=true&local=true")
	\|> json_response_and_validate_schema(200) == []
	end

	test "the home timeline excludes posts from users in exclusive lists", %{
	user: user,
	conn: conn
	} do
	other_user1 = insert(:user)
	other_user2 = insert(:user)

	{:ok, user, other_user1} = User.follow(user, other_user1)
	{:ok, user, other_user2} = User.follow(user, other_user2)

	{:ok, list} = Pleroma.List.create(%{title: "foo", exclusive: true}, user)
	{:ok, _list} = Pleroma.List.follow(list, other_user1)

	{:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi"})
	{:ok, %{id: activity2_id}} = CommonAPI.post(other_user2, %{status: "hi too"})

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^activity2_id}] = response
	end
	end

	describe "public" do
	test "the public timeline", %{conn: conn} do
	user = insert(:user)

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

	remote = insert(:note_activity, local: false)

	assert conn
	\|> get("/api/v1/timelines/public?local=False")
	\|> json_response_and_validate_schema(:ok)
	\|> length == 3

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=True")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=True")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=True&only_media=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=1")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	remote_id = remote.id

	assert [%{"id" => ^remote_id}] =
	conn
	\|> get("/api/v1/timelines/public?remote=true")
	\|> json_response_and_validate_schema(:ok)

	with_media_id = with_media.id

	assert [%{"id" => ^with_media_id}] =
	conn
	\|> get("/api/v1/timelines/public?only_media=true")
	\|> json_response_and_validate_schema(:ok)

	assert conn
	\|> get("/api/v1/timelines/public?remote=true&only_media=true")
	\|> json_response_and_validate_schema(:ok) == []

	# does not contain repeats
	{:ok, _} = CommonAPI.repeat(activity.id, user)

	assert [_, _] =
	conn
	\|> get("/api/v1/timelines/public?local=true")
	\|> json_response_and_validate_schema(:ok)
	end

	test "the public timeline includes only public statuses for an authenticated user" do
	%{user: user, conn: conn} = oauth_access(["read:statuses"])

	{:ok, _activity} = CommonAPI.post(user, %{status: "test"})
	{:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "private"})
	{:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "unlisted"})
	{:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "direct"})

	res_conn = get(conn, "/api/v1/timelines/public")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end

	test "doesn't return replies if follower is posting with blocked user" do
	%{conn: conn, user: blocker} = oauth_access(["read:statuses"])
	[blockee, friend] = insert_list(2, :user)
	{:ok, blocker, friend} = User.follow(blocker, friend)
	{:ok, _} = User.block(blocker, blockee)

	conn = assign(conn, :user, blocker)

	{:ok, %{id: activity_id} = activity} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, reply_from_blockee} =
	CommonAPI.post(blockee, %{status: "heya", in_reply_to_status_id: activity})

	{:ok, _reply_from_friend} =
	CommonAPI.post(friend, %{status: "status", in_reply_to_status_id: reply_from_blockee})

	# Still shows replies from yourself
	{:ok, %{id: reply_from_me}} =
	CommonAPI.post(blocker, %{status: "status", in_reply_to_status_id: reply_from_blockee})

	response =
	get(conn, "/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 2
	[%{"id" => ^reply_from_me}, %{"id" => ^activity_id}] = response
	end

	test "doesn't return posts from users who blocked you when :blockers_visible is disabled" do
	clear_config([:activitypub, :blockers_visible], false)

	%{conn: conn, user: blockee} = oauth_access(["read:statuses"])
	blocker = insert(:user)
	{:ok, _} = User.block(blocker, blockee)

	conn = assign(conn, :user, blockee)

	{:ok, _} = CommonAPI.post(blocker, %{status: "hey!"})

	response =
	get(conn, "/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 0
	end

	test "doesn't return replies if follow is posting with users from blocked domain" do
	%{conn: conn, user: blocker} = oauth_access(["read:statuses"])
	friend = insert(:user)
	blockee = insert(:user, ap_id: "https://example.com/users/blocked")
	{:ok, blocker, friend} = User.follow(blocker, friend)
	{:ok, blocker} = User.block_domain(blocker, "example.com")

	conn = assign(conn, :user, blocker)

	{:ok, %{id: activity_id} = activity} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, reply_from_blockee} =
	- CommonAPI.post(blockee, %{status: "heya", in_reply_to_status_id: activity})
	+ post_as_remote(blockee, %{status: "heya", in_reply_to_status_id: activity})

	{:ok, _reply_from_friend} =
	CommonAPI.post(friend, %{status: "status", in_reply_to_status_id: reply_from_blockee})

	res_conn = get(conn, "/api/v1/timelines/public")

	activities = json_response_and_validate_schema(res_conn, 200)
	[%{"id" => ^activity_id}] = activities
	end

	test "can be filtered by instance", %{conn: conn} do
	user = insert(:user, ap_id: "https://lain.com/users/lain")
	insert(:note_activity, local: false)
	insert(:note_activity, local: false)

	- {:ok, _} = CommonAPI.post(user, %{status: "test"})
	+ {:ok, _} = post_as_remote(user, %{status: "test"})

	conn = get(conn, "/api/v1/timelines/public?instance=lain.com")

	assert length(json_response_and_validate_schema(conn, :ok)) == 1
	end

	test "muted emotions", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])

	conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/timelines/public?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "should return local-only posts for authenticated users" do
	user = insert(:user)
	%{user: _reader, conn: conn} = oauth_access(["read:statuses"])

	{:ok, %{id: id}} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	result =
	conn
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id}] = result
	end

	test "should not return local-only posts for users without read:statuses" do
	user = insert(:user)
	%{user: _reader, conn: conn} = oauth_access([])

	{:ok, _activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	result =
	conn
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [] = result
	end

	test "should not return local-only posts for anonymous users" do
	user = insert(:user)

	{:ok, _activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	result =
	build_conn()
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [] = result
	end
	end

	defp local_and_remote_activities do
	insert(:note_activity)
	insert(:note_activity, local: false)
	:ok
	end

	describe "public with restrict unauthenticated timeline for local and federated timelines" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :timelines, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	test "if user is unauthenticated", %{conn: conn} do
	res_conn = get(conn, "/api/v1/timelines/public?local=true")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}

	res_conn = get(conn, "/api/v1/timelines/public?local=false")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}
	end

	test "if user is authenticated" do
	%{conn: conn} = oauth_access(["read:statuses"])

	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "public with restrict unauthenticated timeline for local" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :timelines, :local], true)

	test "if user is unauthenticated", %{conn: conn} do
	res_conn = get(conn, "/api/v1/timelines/public?local=true")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end

	test "if user is authenticated", %{conn: _conn} do
	%{conn: conn} = oauth_access(["read:statuses"])

	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "public with restrict unauthenticated timeline for remote" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	test "if user is unauthenticated", %{conn: conn} do
	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}
	end

	test "if user is authenticated", %{conn: _conn} do
	%{conn: conn} = oauth_access(["read:statuses"])

	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "direct" do
	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two, user_one} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	status: "Hi @#{user_two.nickname}!",
	visibility: "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	status: "Hi @#{user_two.nickname}!",
	visibility: "private"
	})

	conn_user_two =
	conn
	\|> assign(:user, user_two)
	\|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))

	# Only direct should be visible here
	res_conn = get(conn_user_two, "/api/v1/timelines/direct")

	assert [status] = json_response_and_validate_schema(res_conn, :ok)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see their own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> assign(:token, insert(:oauth_token, user: user_one, scopes: ["read:statuses"]))
	\|> get("/api/v1/timelines/direct")

	[status] = json_response_and_validate_schema(res_conn, :ok)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn = get(conn_user_two, "/api/v1/timelines/home")

	[_s1, _s2] = json_response_and_validate_schema(res_conn, :ok)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	status: "Hi @#{user_two.nickname}!",
	visibility: "direct"
	})
	end)

	res_conn = get(conn_user_two, "/api/v1/timelines/direct")

	statuses = json_response_and_validate_schema(res_conn, :ok)
	assert length(statuses) == 20

	max_id = List.last(statuses)["id"]

	res_conn = get(conn_user_two, "/api/v1/timelines/direct?max_id=#{max_id}")

	assert [status] = json_response_and_validate_schema(res_conn, :ok)

	assert status["url"] != direct.data["id"]
	end

	test "doesn't include DMs from blocked users" do
	%{user: blocker, conn: conn} = oauth_access(["read:statuses"])
	blocked = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(blocker, blocked)

	{:ok, _blocked_direct} =
	CommonAPI.post(blocked, %{
	status: "Hi @#{blocker.nickname}!",
	visibility: "direct"
	})

	{:ok, direct} =
	CommonAPI.post(other_user, %{
	status: "Hi @#{blocker.nickname}!",
	visibility: "direct"
	})

	res_conn = get(conn, "/api/v1/timelines/direct")

	[status] = json_response_and_validate_schema(res_conn, :ok)
	assert status["id"] == direct.id
	end
	end

	describe "list" do
	setup do: oauth_access(["read:lists"])

	test "does not contain retoots", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(user, %{status: "Marisa is cute."})
	{:ok, activity_two} = CommonAPI.post(other_user, %{status: "Marisa is stupid."})
	{:ok, _} = CommonAPI.repeat(activity_one.id, other_user)

	{:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn = get(conn, "/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)

	assert id == to_string(activity_two.id)
	end

	test "works with pagination", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	Enum.each(1..30, fn i ->
	CommonAPI.post(other_user, %{status: "post number #{i}"})
	end)

	res =
	get(conn, "/api/v1/timelines/list/#{list.id}?limit=1")
	\|> json_response_and_validate_schema(:ok)

	assert length(res) == 1

	[first] = res

	res =
	get(conn, "/api/v1/timelines/list/#{list.id}?max_id=#{first["id"]}&limit=30")
	\|> json_response_and_validate_schema(:ok)

	assert length(res) == 29
	end

	test "list timeline", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, _activity_one} = CommonAPI.post(user, %{status: "Marisa is cute."})
	{:ok, activity_two} = CommonAPI.post(other_user, %{status: "Marisa is cute."})
	{:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn = get(conn, "/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{
	user: user,
	conn: conn
	} do
	other_user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(other_user, %{status: "Marisa is cute."})

	{:ok, _activity_two} =
	CommonAPI.post(other_user, %{
	status: "Marisa is cute.",
	visibility: "private"
	})

	{:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn = get(conn, "/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)

	assert id == to_string(activity_one.id)
	end

	test "muted emotions", %{user: user, conn: conn} do
	user2 = insert(:user)
	user3 = insert(:user)
	{:ok, activity} = CommonAPI.post(user2, %{status: "."})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user3, "🎅")
	User.mute(user, user3)

	{:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, user2)

	result =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "filtering", %{user: user, conn: conn} do
	{:ok, list} = Pleroma.List.create(%{title: "name"}, user)

	local_user = insert(:user)
	{:ok, local_activity} = CommonAPI.post(local_user, %{status: "Marisa is stupid."})
	with_media = create_with_media_activity(local_user)
	{:ok, list} = Pleroma.List.follow(list, local_user)

	remote_user = insert(:user, local: false)
	remote_activity = create_remote_activity(remote_user)
	{:ok, list} = Pleroma.List.follow(list, remote_user)

	all_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in all_ids
	assert with_media.id in all_ids
	assert remote_activity.id in all_ids

	only_local_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?local=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in only_local_ids
	assert with_media.id in only_local_ids
	refute remote_activity.id in only_local_ids

	only_local_media_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?local=true&only_media=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in only_local_media_ids
	assert with_media.id in only_local_media_ids
	refute remote_activity.id in only_local_media_ids

	remote_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?remote=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in remote_ids
	refute with_media.id in remote_ids
	assert remote_activity.id in remote_ids

	assert conn
	\|> get("/api/v1/timelines/list/#{list.id}?remote=true&only_media=true")
	\|> json_response_and_validate_schema(200) == []

	only_media_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?only_media=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in only_media_ids
	assert with_media.id in only_media_ids
	refute remote_activity.id in only_media_ids

	assert conn
	\|> get("/api/v1/timelines/list/#{list.id}?only_media=true&local=true&remote=true")
	\|> json_response_and_validate_schema(200) == []
	end
	end

	describe "hashtag" do
	setup do: oauth_access(["n/a"])

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	{:ok, activity} = CommonAPI.post(following, %{status: "test #2hu"})
	with_media = create_with_media_activity(following)

	remote = insert(:user, local: false)
	remote_activity = create_remote_activity(remote)

	all_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in all_ids
	assert with_media.id in all_ids
	assert remote_activity.id in all_ids

	# works for different capitalization too
	all_ids =
	conn
	\|> get("/api/v1/timelines/tag/2HU")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in all_ids
	assert with_media.id in all_ids
	assert remote_activity.id in all_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?local=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote_activity.id in local_ids

	remote_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?remote=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in remote_ids
	refute with_media.id in remote_ids
	assert remote_activity.id in remote_ids

	media_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in media_ids
	assert with_media.id in media_ids
	refute remote_activity.id in media_ids

	media_local_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true&local=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in media_local_ids
	assert with_media.id in media_local_ids
	refute remote_activity.id in media_local_ids

	ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true&local=true&remote=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in ids
	refute with_media.id in ids
	refute remote_activity.id in ids

	assert conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true&remote=true")
	\|> json_response_and_validate_schema(:ok) == []
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{status: "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{status: "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{status: "#test #none"})

	for hashtag_timeline_mode <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_mode)

	any_test = get(conn, "/api/v1/timelines/tag/test?any[]=test1")

	[status_none, status_test1, status_test] =
	json_response_and_validate_schema(any_test, :ok)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test = get(conn, "/api/v1/timelines/tag/test?all[]=test1&none[]=none")

	assert [status_test1] == json_response_and_validate_schema(restricted_test, :ok)

	all_test = get(conn, "/api/v1/timelines/tag/test?all[]=none")

	assert [status_none] == json_response_and_validate_schema(all_test, :ok)
	end
	end

	test "multi-hashtag timeline pagination returns unique statuses", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_one} = CommonAPI.post(user, %{status: "#test #test1"})
	{:ok, activity_two} = CommonAPI.post(user, %{status: "#test #test1"})
	{:ok, activity_three} = CommonAPI.post(user, %{status: "#test #test1"})

	for hashtag_timeline_mode <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_mode)

	first_page =
	conn
	\|> get("/api/v1/timelines/tag/test?any[]=test1&limit=2")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.map(first_page, & &1["id"]) ==
	Enum.map([activity_three, activity_two], &to_string(&1.id))

	second_page =
	conn
	\|> get("/api/v1/timelines/tag/test?any[]=test1&limit=2&max_id=#{activity_two.id}")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.map(second_page, & &1["id"]) == [to_string(activity_one.id)]
	end
	end

	test "muted emotions", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])

	conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "test #2hu"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/timelines/tag/2hu")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/timelines/tag/2hu?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end
	end

	describe "hashtag timeline handling of restrict_unauthenticated setting" do
	setup do
	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "test #tag1"})
	{:ok, _activity2} = CommonAPI.post(user, %{status: "test #tag1"})

	activity1
	\|> Ecto.Changeset.change(%{local: false})
	\|> Pleroma.Repo.update()

	base_uri = "/api/v1/timelines/tag/tag1"
	error_response = %{"error" => "authorization required for timeline view"}

	%{base_uri: base_uri, error_response: error_response}
	end

	defp ensure_authenticated_access(base_uri) do
	%{conn: auth_conn} = oauth_access(["read:statuses"])

	res_conn = get(auth_conn, "#{base_uri}?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(auth_conn, "#{base_uri}?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end

	test "with default settings on private instances, returns 403 for unauthenticated users", %{
	conn: conn,
	base_uri: base_uri,
	error_response: error_response
	} do
	clear_config([:instance, :public], false)
	clear_config([:restrict_unauthenticated, :timelines])

	for local <- [true, false] do
	res_conn = get(conn, "#{base_uri}?local=#{local}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response
	end

	ensure_authenticated_access(base_uri)
	end

	test "with `%{local: true, federated: true}`, returns 403 for unauthenticated users", %{
	conn: conn,
	base_uri: base_uri,
	error_response: error_response
	} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	for local <- [true, false] do
	res_conn = get(conn, "#{base_uri}?local=#{local}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response
	end

	ensure_authenticated_access(base_uri)
	end

	test "with `%{local: false, federated: true}`, forbids unauthenticated access to federated timeline",
	%{conn: conn, base_uri: base_uri, error_response: error_response} do
	clear_config([:restrict_unauthenticated, :timelines, :local], false)
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	res_conn = get(conn, "#{base_uri}?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "#{base_uri}?local=false")
	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response

	ensure_authenticated_access(base_uri)
	end

	test "with `%{local: true, federated: false}`, forbids unauthenticated access to public timeline" <>
	"(but not to local public activities which are delivered as part of federated timeline)",
	%{conn: conn, base_uri: base_uri, error_response: error_response} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)
	clear_config([:restrict_unauthenticated, :timelines, :federated], false)

	res_conn = get(conn, "#{base_uri}?local=true")
	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response

	# Note: local activities get delivered as part of federated timeline
	res_conn = get(conn, "#{base_uri}?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2

	ensure_authenticated_access(base_uri)
	end
	end

	defp create_remote_activity(user) do
	obj =
	insert(:note, %{
	data: %{
	"to" => [
	"https://www.w3.org/ns/activitystreams#Public",
	User.ap_followers(user)
	]
	},
	user: user
	})

	insert(:note_activity, %{
	note: obj,
	recipients: [
	"https://www.w3.org/ns/activitystreams#Public",
	User.ap_followers(user)
	],
	user: user,
	local: false
	})
	end

	defp create_with_media_activity(user) do
	obj = insert(:attachment_note, user: user)

	insert(:note_activity, %{
	note: obj,
	recipients: ["https://www.w3.org/ns/activitystreams#Public", User.ap_followers(user)],
	user: user
	})
	end
	end
	diff --git a/test/pleroma/web/rich_media/backfill_test.exs b/test/pleroma/web/rich_media/backfill_test.exs
	index 071f9b48a..4c9a5e45c 100644
	--- a/test/pleroma/web/rich_media/backfill_test.exs
	+++ b/test/pleroma/web/rich_media/backfill_test.exs
	@@ -1,171 +1,173 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.BackfillTest do
	use Pleroma.DataCase

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Backfill
	alias Pleroma.Web.RichMedia.Card

	import Mox
	import Pleroma.Factory

	setup do
	clear_config([:rich_media, :enabled], true)

	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)

	:ok
	end

	test "sets a negative cache entry for an error" do
	url = "https://bad.example.com/"
	url_hash = Card.url_to_hash(url)

	Tesla.Mock.mock(fn %{url: ^url} -> :error end)

	Pleroma.CachexMock
	\|> expect(:put, fn :rich_media_cache, ^url_hash, :error, ttl: _ -> {:ok, true} end)

	Backfill.run(%{"url" => url})
	end

	test "sets a warm_cache entry" do
	url = "https://good.example.com/"
	url_hash = Card.url_to_hash(url)

	Tesla.Mock.mock(fn %{url: ^url} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: "<head><meta name=\"twitter:title\" content=\"Cofe\"></head>"
	}}
	end)

	Pleroma.CachexMock
	\|> expect(:put, fn :rich_media_cache,
	^url_hash,
	%Pleroma.Web.RichMedia.Card{url_hash: ^url_hash} ->
	{:ok, true}
	end)

	Backfill.run(%{"url" => url})
	end

	test "streams out update when stream == true" do
	url = "https://example.com"
	user = insert(:user)

	Tesla.Mock.mock(fn %{url: ^url} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: "<head><meta name=\"twitter:title\" content=\"Cofe\"></head>"
	}}
	end)

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

	Pleroma.CachexMock
	\|> expect(:put, fn :rich_media_cache, _, _ -> {:ok, true} end)

	Pleroma.Web.ActivityPub.ActivityPubMock
	\|> expect(:stream_out, fn %Pleroma.Activity{id: id} ->
	assert id == activity.id
	:ok
	end)

	Backfill.run(%{"url" => url, "activity_id" => activity.id, "stream" => true})
	end

	test "does not stream out update when stream == false" do
	url = "https://example.com"
	user = insert(:user)

	Tesla.Mock.mock(fn %{url: ^url} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: "<head><meta name=\"twitter:title\" content=\"Cofe\"></head>"
	}}
	end)

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

	Pleroma.CachexMock
	\|> expect(:put, fn :rich_media_cache, _, _ -> {:ok, true} end)

	Pleroma.Web.ActivityPub.ActivityPubMock
	\|> deny(:stream_out, 1)

	Backfill.run(%{"url" => url, "activity_id" => "#{activity.data["id"]}", "stream" => false})
	end

	# NOTE: Below two MastoAPI tests cover almost the same code paths.
	# index.json will always prefetch rich media, while show.json will try to get the card and
	# fetch it when it isn't cached (both use Card.get_by_activity in the end).
	# So if index.json doesn't fetch the rich media, show.json will when it renders the post,
	# hence why index.json test will only call ActivityPub.stream_out twice,
	# if streaming is re-enabled for in both.
	test "does not stream out in MastoAPI StatusView index" do
	url = "https://example.com"
	user = insert(:user)

	Tesla.Mock.mock(fn %{url: ^url} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: "<head><meta name=\"twitter:title\" content=\"Cofe\"></head>"
	}}
	end)

	- # CommonAPI federation processing will stream out once as a new post
	+ # The new post is streamed out once when it is created and once more when
	+ # the rich media backfill for it completes
	Pleroma.Web.ActivityPub.ActivityPubMock
	- \|> expect(:stream_out, 1, fn _ -> :ok end)
	+ \|> expect(:stream_out, 2, fn _ -> :ok end)

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

	# Clear cache to force backfill below
	Pleroma.Activity.HTML.invalidate_cache_for(activity.id)
	Pleroma.Web.RichMedia.Card.delete(url)

	Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
	activities: [activity],
	as: :activity
	})

	ObanHelpers.perform_all()
	end

	test "does not stream out in MastoAPI StatusView show" do
	url = "https://example.com"
	user = insert(:user)

	Tesla.Mock.mock(fn %{url: ^url} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: "<head><meta name=\"twitter:title\" content=\"Cofe\"></head>"
	}}
	end)

	- # CommonAPI federation processing will stream out once as a new post
	+ # The new post is streamed out once when it is created and once more when
	+ # the rich media backfill for it completes
	Pleroma.Web.ActivityPub.ActivityPubMock
	- \|> expect(:stream_out, 1, fn _ -> :ok end)
	+ \|> expect(:stream_out, 2, fn _ -> :ok end)

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

	# Clear cache to force backfill below
	Pleroma.Activity.HTML.invalidate_cache_for(activity.id)
	Pleroma.Web.RichMedia.Card.delete(url)

	Pleroma.Web.MastodonAPI.StatusView.render("show.json", activity: activity)
	ObanHelpers.perform_all()
	end
	end
	diff --git a/test/pleroma/web/streamer_test.exs b/test/pleroma/web/streamer_test.exs
	index 7610b3379..3ecddfeee 100644
	--- a/test/pleroma/web/streamer_test.exs
	+++ b/test/pleroma/web/streamer_test.exs
	@@ -1,1131 +1,1131 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StreamerTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Conversation.Participation
	alias Pleroma.List
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.StreamerView

	@moduletag needs_streamer: true, capture_log: true

	setup do
	clear_config([:instance, :skip_thread_containment])
	Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)

	:ok
	end

	describe "get_topic/_ (unauthenticated)" do
	test "allows no stream" do
	assert {:ok, nil} = Streamer.get_topic(nil, nil, nil)
	end

	test "allows public" do
	assert {:ok, "public"} = Streamer.get_topic("public", nil, nil)
	assert {:ok, "public:local"} = Streamer.get_topic("public:local", nil, nil)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", nil, nil)
	assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", nil, nil)
	end

	test "rejects local public streams if restricted_unauthenticated is on" do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)

	assert {:error, :unauthorized} = Streamer.get_topic("public:local", nil, nil)
	assert {:error, :unauthorized} = Streamer.get_topic("public:local:media", nil, nil)
	end

	test "rejects remote public streams if restricted_unauthenticated is on" do
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	assert {:error, :unauthorized} = Streamer.get_topic("public", nil, nil)
	assert {:error, :unauthorized} = Streamer.get_topic("public:media", nil, nil)

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
	end

	test "allows instance streams" do
	assert {:ok, "public:remote:lain.com"} =
	Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})

	assert {:ok, "public:remote:media:lain.com"} =
	Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
	end

	test "allows hashtag streams" do
	assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", nil, nil, %{"tag" => "cofe"})
	end

	test "disallows user streams" do
	assert {:error, _} = Streamer.get_topic("user", nil, nil)
	assert {:error, _} = Streamer.get_topic("user:notification", nil, nil)
	assert {:error, _} = Streamer.get_topic("direct", nil, nil)
	end

	test "disallows list streams" do
	assert {:error, _} = Streamer.get_topic("list", nil, nil, %{"list" => 42})
	end
	end

	describe "get_topic/_ (authenticated)" do
	setup do: oauth_access(["read"])

	test "allows public streams (regardless of OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	with oauth_token <- [nil, read_oauth_token] do
	assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
	assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)

	assert {:ok, "public:local:media"} =
	Streamer.get_topic("public:local:media", user, oauth_token)
	end
	end

	test "allows local public streams if restricted_unauthenticated is on", %{
	user: user,
	token: oauth_token
	} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)

	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)

	assert {:ok, "public:local:media"} =
	Streamer.get_topic("public:local:media", user, oauth_token)

	for token <- [read_notifications_token, badly_scoped_token] do
	assert {:error, :unauthorized} = Streamer.get_topic("public:local", user, token)

	assert {:error, :unauthorized} = Streamer.get_topic("public:local:media", user, token)
	end
	end

	test "allows remote public streams if restricted_unauthenticated is on", %{
	user: user,
	token: oauth_token
	} do
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)

	assert {:ok, "public:remote:lain.com"} =
	Streamer.get_topic("public:remote", user, oauth_token, %{"instance" => "lain.com"})

	assert {:ok, "public:remote:media:lain.com"} =
	Streamer.get_topic("public:remote:media", user, oauth_token, %{
	"instance" => "lain.com"
	})

	for token <- [read_notifications_token, badly_scoped_token] do
	assert {:error, :unauthorized} = Streamer.get_topic("public", user, token)
	assert {:error, :unauthorized} = Streamer.get_topic("public:media", user, token)

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote", user, token, %{
	"instance" => "lain.com"
	})

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote:media", user, token, %{
	"instance" => "lain.com"
	})
	end
	end

	test "allows user streams (with proper OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: read_statuses_token} = oauth_access(["read:statuses"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	expected_user_topic = "user:#{user.id}"
	expected_notification_topic = "user:notification:#{user.id}"
	expected_direct_topic = "direct:#{user.id}"
	expected_pleroma_chat_topic = "user:pleroma_chat:#{user.id}"

	for valid_user_token <- [read_oauth_token, read_statuses_token] do
	assert {:ok, ^expected_user_topic} = Streamer.get_topic("user", user, valid_user_token)

	assert {:ok, ^expected_direct_topic} =
	Streamer.get_topic("direct", user, valid_user_token)

	assert {:ok, ^expected_pleroma_chat_topic} =
	Streamer.get_topic("user:pleroma_chat", user, valid_user_token)
	end

	for invalid_user_token <- [read_notifications_token, badly_scoped_token],
	user_topic <- ["user", "direct", "user:pleroma_chat"] do
	assert {:error, :unauthorized} = Streamer.get_topic(user_topic, user, invalid_user_token)
	end

	for valid_notification_token <- [read_oauth_token, read_notifications_token] do
	assert {:ok, ^expected_notification_topic} =
	Streamer.get_topic("user:notification", user, valid_notification_token)
	end

	for invalid_notification_token <- [read_statuses_token, badly_scoped_token] do
	assert {:error, :unauthorized} =
	Streamer.get_topic("user:notification", user, invalid_notification_token)
	end
	end

	test "allows hashtag streams (regardless of OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	for oauth_token <- [nil, read_oauth_token] do
	assert {:ok, "hashtag:cofe"} =
	Streamer.get_topic("hashtag", user, oauth_token, %{"tag" => "cofe"})
	end
	end

	test "disallows registering to another user's stream", %{user: user, token: read_oauth_token} do
	another_user = insert(:user)
	assert {:error, _} = Streamer.get_topic("user:#{another_user.id}", user, read_oauth_token)

	assert {:error, _} =
	Streamer.get_topic("user:notification:#{another_user.id}", user, read_oauth_token)

	assert {:error, _} = Streamer.get_topic("direct:#{another_user.id}", user, read_oauth_token)
	end

	test "allows list stream that are owned by the user (with `read` or `read:lists` scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	%{token: read_lists_token} = oauth_access(["read:lists"], user: user)
	%{token: invalid_token} = oauth_access(["irrelevant:scope"], user: user)
	{:ok, list} = List.create(%{title: "Test"}, user)

	assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, read_oauth_token)

	for valid_token <- [read_oauth_token, read_lists_token] do
	assert {:ok, _} = Streamer.get_topic("list", user, valid_token, %{"list" => list.id})
	end

	assert {:error, _} = Streamer.get_topic("list", user, invalid_token, %{"list" => list.id})
	end

	test "disallows list stream that are not owned by the user", %{user: user, token: oauth_token} do
	another_user = insert(:user)
	{:ok, list} = List.create(%{title: "Test"}, another_user)

	assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, oauth_token)
	assert {:error, _} = Streamer.get_topic("list", user, oauth_token, %{"list" => list.id})
	end
	end

	describe "user streams" do
	setup do
	%{user: user, token: token} = oauth_access(["read"])
	notify = insert(:notification, user: user, activity: build(:note_activity))
	{:ok, %{user: user, notify: notify, token: token}}
	end

	test "it streams the user's post in the 'user' stream", %{user: user, token: oauth_token} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it streams boosts of the user in the 'user' stream", %{user: user, token: oauth_token} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, user)

	assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce, _}
	refute Streamer.filtered_by_user?(user, announce)
	end

	test "it does not stream announces of the user's own posts in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, other_user)

	assert Streamer.filtered_by_user?(user, announce)
	end

	test "it does stream notifications announces of the user's own posts in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, other_user)

	notification =
	Pleroma.Notification
	\|> Repo.get_by(%{user_id: user.id, activity_id: announce.id})
	\|> Repo.preload(:activity)

	refute Streamer.filtered_by_user?(user, notification)
	end

	test "it streams boosts of mastodon user in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

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

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

	{:ok, %Pleroma.Activity{data: _data, local: false} = announce} =
	Pleroma.Web.ActivityPub.Transmogrifier.handle_incoming(data)

	assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce, _}
	refute Streamer.filtered_by_user?(user, announce)
	end

	test "it sends notify to in the 'user' stream", %{
	user: user,
	token: oauth_token,
	notify: notify
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	Streamer.stream("user", notify)

	assert_receive {:render_with_user, _, _, ^notify, _}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it sends notify to in the 'user:notification' stream", %{
	user: user,
	token: oauth_token,
	notify: notify
	} do
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	Streamer.stream("user:notification", notify)

	assert_receive {:render_with_user, _, _, ^notify, _}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it sends chat messages to the 'user:pleroma_chat' stream", %{
	user: user,
	token: oauth_token
	} do
	other_user = insert(:user)

	{:ok, create_activity} =
	CommonAPI.post_chat_message(other_user, user, "hey cirno", idempotency_key: "123")

	object = Object.normalize(create_activity, fetch: false)
	chat = Chat.get(user.id, other_user.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	cm_ref = %{cm_ref \| chat: chat, object: object}

	Streamer.get_topic_and_add_socket("user:pleroma_chat", user, oauth_token)
	Streamer.stream("user:pleroma_chat", {user, cm_ref})

	text =
	StreamerView.render(
	"chat_update.json",
	%{chat_message_reference: cm_ref},
	"user:pleroma_chat:#{user.id}"
	)

	assert text =~ "hey cirno"
	assert_receive {:text, ^text}
	end

	test "it sends chat messages to the 'user' stream", %{user: user, token: oauth_token} do
	other_user = insert(:user)

	{:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey cirno")
	object = Object.normalize(create_activity, fetch: false)
	chat = Chat.get(user.id, other_user.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	cm_ref = %{cm_ref \| chat: chat, object: object}

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	Streamer.stream("user", {user, cm_ref})

	text =
	StreamerView.render(
	"chat_update.json",
	%{chat_message_reference: cm_ref},
	"user:#{user.id}"
	)

	assert text =~ "hey cirno"
	assert_receive {:text, ^text}
	end

	test "it sends chat message notifications to the 'user:notification' stream", %{
	user: user,
	token: oauth_token
	} do
	other_user = insert(:user)

	{:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey")

	notify =
	Repo.get_by(Pleroma.Notification, user_id: user.id, activity_id: create_activity.id)
	\|> Repo.preload(:activity)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	Streamer.stream("user:notification", notify)

	assert_receive {:render_with_user, _, _, ^notify, _}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
	user: user,
	token: oauth_token
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, activity} = CommonAPI.post(user, %{status: ":("})
	{:ok, _} = CommonAPI.favorite(activity.id, blocked)

	refute_receive _
	end

	test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(activity, user)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	refute_receive _
	assert Streamer.filtered_by_user?(user, favorite_activity)
	end

	test "it sends favorite to 'user:notification' stream'", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert notif.activity.id == favorite_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end

	test "it doesn't send the 'user:notification' stream' when a domain is blocked", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	{:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	refute_receive _
	assert Streamer.filtered_by_user?(user, favorite_activity)
	end

	test "it does not filter followed users on blocked domains", %{user: user} do
	followed =
	insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/friend"})

	{:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
	- {:ok, activity} = CommonAPI.post(followed, %{status: "still a friend"})
	+ {:ok, activity} = post_as_remote(followed, %{status: "still a friend"})

	assert Streamer.filtered_by_user?(user, activity)

	{:ok, user, _followed} = User.follow(user, followed)

	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it sends follow activities to the 'user:notification' stream", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert notif.activity.id == follow_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end

	test "it sends follow relationships updates to the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	user_id = user.id
	other_user = insert(:user)
	other_user_id = other_user.id

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, _follower, _followed, _follow_activity} = CommonAPI.follow(other_user, user)

	assert_receive {:text, event}

	assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
	Jason.decode!(event)

	assert %{
	"follower" => %{
	"follower_count" => 0,
	"following_count" => 0,
	"id" => ^user_id
	},
	"following" => %{
	"follower_count" => 0,
	"following_count" => 0,
	"id" => ^other_user_id
	},
	"state" => "follow_pending"
	} = Jason.decode!(payload)

	assert_receive {:text, event}

	assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
	Jason.decode!(event)

	assert %{
	"follower" => %{
	"follower_count" => 0,
	"following_count" => 1,
	"id" => ^user_id
	},
	"following" => %{
	"follower_count" => 1,
	"following_count" => 0,
	"id" => ^other_user_id
	},
	"state" => "follow_accept"
	} = Jason.decode!(payload)
	end

	test "it streams edits in the 'user' stream", %{user: user, token: oauth_token} do
	sender = insert(:user)
	{:ok, _, _, _} = CommonAPI.follow(sender, user)

	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})
	create = Pleroma.Activity.get_create_by_object_ap_id_with_object(activity.object.data["id"])

	assert_receive {:render_with_user, _, "status_update.json", ^create, _}
	refute Streamer.filtered_by_user?(user, edited)
	end

	test "it streams own edits in the 'user' stream", %{user: user, token: oauth_token} do
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, edited} = CommonAPI.update(activity, user, %{status: "mew mew"})
	create = Pleroma.Activity.get_create_by_object_ap_id_with_object(activity.object.data["id"])

	assert_receive {:render_with_user, _, "status_update.json", ^create, _}
	refute Streamer.filtered_by_user?(user, edited)
	end

	test "it streams posts containing followed hashtags on the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	hashtag = insert(:hashtag, %{name: "tenshi"})
	other_user = insert(:user)
	{:ok, user} = User.follow_hashtag(user, hashtag)

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey #tenshi"})

	assert_receive {:render_with_user, _, "update.json", ^activity, _}
	end

	test "should not stream private posts containing followed hashtags on the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	hashtag = insert(:hashtag, %{name: "tenshi"})
	other_user = insert(:user)
	{:ok, user} = User.follow_hashtag(user, hashtag)

	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	{:ok, activity} =
	CommonAPI.post(other_user, %{status: "hey #tenshi", visibility: "private"})

	refute_receive {:render_with_user, _, "update.json", ^activity, _}
	end
	end

	describe "public streams" do
	test "it sends to public (authenticated)" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(other_user, activity)
	end

	test "it sends to public (unauthenticated)" do
	user = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)

	{:ok, activity} = CommonAPI.post(user, %{status: "Test"})
	activity_id = activity.id
	assert_receive {:text, event}
	assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)

	{:ok, _} = CommonAPI.delete(activity.id, user)
	assert_receive {:text, event}
	assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
	end

	test "handles deletions" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})

	Streamer.get_topic_and_add_socket("public", user, oauth_token)

	{:ok, _} = CommonAPI.delete(activity.id, other_user)
	activity_id = activity.id
	assert_receive {:text, event}
	assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
	end

	test "it streams edits in the 'public' stream" do
	sender = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)
	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})
	assert_receive {:text, _}

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])

	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)
	end

	test "it streams multiple edits in the 'public' stream correctly" do
	sender = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)
	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})
	assert_receive {:text, _}

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])

	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew 2"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])
	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id, "content" => "mew mew 2"} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)
	end
	end

	describe "thread_containment/2" do
	test "it filters to user if recipients invalid and thread containment is enabled" do
	clear_config([:instance, :skip_thread_containment], false)
	author = insert(:user)
	%{user: user, token: oauth_token} = oauth_access(["read"])
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)
	assert_receive {:render_with_user, _, _, ^activity, _}
	assert Streamer.filtered_by_user?(user, activity)
	end

	test "it sends message if recipients invalid and thread containment is disabled" do
	clear_config([:instance, :skip_thread_containment], true)
	author = insert(:user)
	%{user: user, token: oauth_token} = oauth_access(["read"])
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
	clear_config([:instance, :skip_thread_containment], false)
	author = insert(:user)
	user = insert(:user, skip_thread_containment: true)
	%{token: oauth_token} = oauth_access(["read"], user: user)
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user, activity)
	end
	end

	describe "blocks" do
	setup do: oauth_access(["read"])

	test "it filters messages involving blocked users", %{user: user, token: oauth_token} do
	blocked_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked_user)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	{:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
	assert_receive {:render_with_user, _, _, ^activity, _}
	assert Streamer.filtered_by_user?(user, activity)
	end

	test "it filters messages transitively involving blocked users", %{
	user: blocker,
	token: blocker_token
	} do
	blockee = insert(:user)
	friend = insert(:user)

	Streamer.get_topic_and_add_socket("public", blocker, blocker_token)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_one, _}
	assert Streamer.filtered_by_user?(blocker, activity_one)

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_two, _}
	assert Streamer.filtered_by_user?(blocker, activity_two)

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_three, _}
	assert Streamer.filtered_by_user?(blocker, activity_three)
	end
	end

	describe "lists" do
	setup do: oauth_access(["read"])

	test "it doesn't send unwanted DMs to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)
	user_c = insert(:user)

	{:ok, user_a, user_b} = User.follow(user_a, user_b)

	{:ok, list} = List.create(%{title: "Test"}, user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, _activity} =
	CommonAPI.post(user_b, %{
	status: "@#{user_c.nickname} Test",
	visibility: "direct"
	})

	refute_receive _
	end

	test "it doesn't send unwanted private posts to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)

	{:ok, list} = List.create(%{title: "Test"}, user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, _activity} =
	CommonAPI.post(user_b, %{
	status: "Test",
	visibility: "private"
	})

	refute_receive _
	end

	test "it sends wanted private posts to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)

	{:ok, user_a, user_b} = User.follow(user_a, user_b)

	{:ok, list} = List.create(%{title: "Test"}, user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, activity} =
	CommonAPI.post(user_b, %{
	status: "Test",
	visibility: "private"
	})

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user_a, activity)
	end
	end

	describe "muted reblogs" do
	setup do: oauth_access(["read"])

	test "it filters muted reblogs", %{user: user1, token: user1_token} do
	user2 = insert(:user)
	user3 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})

	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, announce_activity} = CommonAPI.repeat(create_activity.id, user2)
	assert_receive {:render_with_user, _, _, ^announce_activity, _}
	assert Streamer.filtered_by_user?(user1, announce_activity)
	end

	test "it filters reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, _announce_activity} = CommonAPI.repeat(create_activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert Streamer.filtered_by_user?(user1, notif)
	end

	test "it sends non-reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, _favorite_activity} = CommonAPI.favorite(create_activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	refute Streamer.filtered_by_user?(user1, notif)
	end
	end

	describe "muted threads" do
	test "it filters posts from muted threads" do
	user = insert(:user)
	%{user: user2, token: user2_token} = oauth_access(["read"])
	Streamer.get_topic_and_add_socket("user", user2, user2_token)

	{:ok, user2, user, _activity} = CommonAPI.follow(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(activity, user2)

	assert_receive {:render_with_user, _, _, ^activity, _}
	assert Streamer.filtered_by_user?(user2, activity)
	end
	end

	describe "direct streams" do
	setup do: oauth_access(["read"])

	test "it sends conversation update to the 'direct' stream", %{user: user, token: oauth_token} do
	another_user = insert(:user)

	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

	{:ok, _create_activity} =
	CommonAPI.post(another_user, %{
	status: "hey @#{user.nickname}",
	visibility: "direct"
	})

	assert_receive {:text, received_event}

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	[participation] = Participation.for_user(user)
	assert last_status["pleroma"]["direct_conversation_id"] == participation.id
	end

	test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted",
	%{user: user, token: oauth_token} do
	another_user = insert(:user)

	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

	{:ok, create_activity} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname}",
	visibility: "direct"
	})

	create_activity_id = create_activity.id
	assert_receive {:render_with_user, _, _, ^create_activity, _}
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)

	{:ok, _} = CommonAPI.delete(create_activity_id, another_user)

	assert_receive {:text, received_event}

	assert %{"event" => "delete", "payload" => ^create_activity_id} =
	Jason.decode!(received_event)

	refute_receive _
	end

	@tag :erratic
	test "it sends conversation update to the 'direct' stream when a message is deleted", %{
	user: user,
	token: oauth_token
	} do
	another_user = insert(:user)
	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

	{:ok, create_activity} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname}",
	visibility: "direct"
	})

	{:ok, create_activity2} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname} 2",
	in_reply_to_status_id: create_activity.id,
	visibility: "direct"
	})

	assert_receive {:render_with_user, _, _, ^create_activity, _}
	assert_receive {:render_with_user, _, _, ^create_activity2, _}
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)

	{:ok, _} = CommonAPI.delete(create_activity2.id, another_user)

	assert_receive {:text, received_event}
	assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)

	assert_receive {:text, received_event}

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	assert last_status["id"] == to_string(create_activity.id)
	end
	end

	describe "stop streaming if token got revoked" do
	setup do
	child_proc = fn start, finalize ->
	fn ->
	start.()

	receive do
	{StreamerTest, :ready} ->
	assert_receive {:render_with_user, _, "update.json", _, _}

	receive do
	{StreamerTest, :revoked} -> finalize.()
	end
	end
	end
	end

	starter = fn user, token ->
	fn -> Streamer.get_topic_and_add_socket("user", user, token) end
	end

	hit = fn -> assert_receive :close end
	miss = fn -> refute_receive :close end

	send_all = fn tasks, thing -> Enum.each(tasks, &send(&1.pid, thing)) end

	%{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	miss: miss,
	send_all: send_all
	}
	end

	test "do not revoke other tokens", %{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	miss: miss,
	send_all: send_all
	} do
	%{user: user, token: token} = oauth_access(["read"])
	%{token: token2} = oauth_access(["read"], user: user)
	%{user: user2, token: user2_token} = oauth_access(["read"])

	post_user = insert(:user)
	CommonAPI.follow(post_user, user)
	CommonAPI.follow(post_user, user2)

	tasks = [
	Task.async(child_proc.(starter.(user, token), hit)),
	Task.async(child_proc.(starter.(user, token2), miss)),
	Task.async(child_proc.(starter.(user2, user2_token), miss))
	]

	{:ok, _} =
	CommonAPI.post(post_user, %{
	status: "hi"
	})

	send_all.(tasks, {StreamerTest, :ready})

	Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)

	send_all.(tasks, {StreamerTest, :revoked})

	Enum.each(tasks, &Task.await/1)
	end

	test "revoke all streams for this token", %{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	send_all: send_all
	} do
	%{user: user, token: token} = oauth_access(["read"])

	post_user = insert(:user)
	CommonAPI.follow(post_user, user)

	tasks = [
	Task.async(child_proc.(starter.(user, token), hit)),
	Task.async(child_proc.(starter.(user, token), hit))
	]

	{:ok, _} =
	CommonAPI.post(post_user, %{
	status: "hi"
	})

	send_all.(tasks, {StreamerTest, :ready})

	Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)

	send_all.(tasks, {StreamerTest, :revoked})

	Enum.each(tasks, &Task.await/1)
	end
	end
	end
	diff --git a/test/pleroma/workers/receiver_worker_test.exs b/test/pleroma/workers/receiver_worker_test.exs
	index ea05f38f1..e5e3ab4e5 100644
	--- a/test/pleroma/workers/receiver_worker_test.exs
	+++ b/test/pleroma/workers/receiver_worker_test.exs
	@@ -1,324 +1,323 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.ReceiverWorkerTest do
	use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.User
	- alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.ReceiverWorker

	defp signature_headers_for(%User{} = signer) do
	[
	{"host", "local.test"},
	{"date", "Thu, 25 Jul 2024 13:33:31 GMT"},
	{"digest", "SHA-256=fake-digest"},
	{"content-type", "application/activity+json"},
	{
	"signature",
	"keyId=\"#{signer.ap_id}#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	}
	]
	end

	defp perform_incoming(params) do
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end

	test "it does not retry MRF reject" do
	params = insert(:note).data

	with_mock Pleroma.Web.ActivityPub.Transmogrifier,
	handle_incoming: fn _ -> {:reject, "MRF"} end do
	assert {:cancel, {:reject, "MRF"}} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end

	test "it does not retry ObjectValidator reject" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", Pleroma.Web.ActivityPub.Utils.generate_activity_id())
	\|> Map.put("object", %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id()
	})

	with_mock Pleroma.Web.ActivityPub.ObjectValidator, [:passthrough],
	validate: fn _, _ -> {:error, %Ecto.Changeset{}} end do
	assert {:cancel, {:error, %Ecto.Changeset{}}} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end

	test "it does not retry duplicates" do
	params = insert(:note_activity).data

	assert {:cancel, :already_present} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end

	describe "cancels on a failed user fetch" do
	setup do
	Tesla.Mock.mock(fn
	%{url: "https://springfield.social/users/bart"} ->
	%Tesla.Env{
	status: 403,
	body: ""
	}

	%{url: "https://springfield.social/users/troymcclure"} ->
	%Tesla.Env{
	status: 404,
	body: ""
	}

	%{url: "https://springfield.social/users/hankscorpio"} ->
	%Tesla.Env{
	status: 410,
	body: ""
	}
	end)
	end

	test "when request returns a 403" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/bart")

	assert {:cancel, {:error, :forbidden}} = perform_incoming(params)
	end

	test "when request returns a 404" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/troymcclure")

	assert {:cancel, {:error, :not_found}} = perform_incoming(params)
	end

	test "when request returns a 410" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/hankscorpio")

	assert {:cancel, {:error, :not_found}} = perform_incoming(params)
	end

	test "when user account is disabled" do
	user = insert(:user)

	fake_activity = URI.parse(user.ap_id) \|> Map.put(:path, "/fake-activity") \|> to_string

	params =
	insert(:note_activity, user: user).data
	\|> Map.put("id", fake_activity)

	{:ok, %User{}} = User.set_activation(user, false)

	assert {:cancel, {:user_active, false}} = perform_incoming(params)
	end
	end

	test "cancels due to origin containment" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", "https://notorigindomain.com/activity")

	assert {:cancel, :origin_containment_failed} = perform_incoming(params)
	end

	test "canceled due to deleted object" do
	params =
	insert(:announce_activity).data
	\|> Map.put("object", "http://localhost:4001/deleted")

	Tesla.Mock.mock(fn
	%{url: "http://localhost:4001/deleted"} ->
	%Tesla.Env{
	status: 404,
	body: ""
	}
	end)

	assert {:cancel, _} = perform_incoming(params)
	end

	test "delegates legacy failed-signature metadata jobs instead of processing them as trusted" 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/legacy-forged-note"

	create = %{
	"type" => "Create",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/legacy-forged-create",
	"context" => "https://two.com/contexts/legacy-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/legacy-forged-create",
	"content" => "forged post",
	"published" => "2024-07-25T13:33:31Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => []
	}
	}

	assert {:cancel, :actor_signature_mismatch} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"method" => "POST",
	"params" => create,
	"req_headers" => signature_headers_for(alice),
	"request_path" => "/inbox",
	"query_string" => ""
	}
	})

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

	test "fails closed for the old persisted failed-signature job shape" 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/old-shape-forged-note"

	create = %{
	"type" => "Create",
	"actor" => bob.ap_id,
	"id" => "https://two.com/activities/old-shape-forged-create",
	"context" => "https://two.com/contexts/old-shape-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/old-shape-forged-create",
	"content" => "forged post",
	"published" => "2024-07-25T13:33:31Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => []
	}
	}

	assert {:cancel, :missing_signature_retry_metadata} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => create,
	"req_headers" => signature_headers_for(alice),
	"timeout" => 20_000
	}
	})

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

	test "fails closed for legacy retry jobs missing one metadata field" do
	alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	params = insert(:note_activity).data

	assert {:cancel, :missing_signature_retry_metadata} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"method" => "POST",
	"params" => params,
	"req_headers" => signature_headers_for(alice),
	"request_path" => "/inbox"
	}
	})
	end

	test "fails closed for malformed legacy metadata jobs without params" do
	assert {:cancel, :missing_signature_retry_metadata} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"req_headers" => [],
	"timeout" => 20_000
	}
	})
	end

	describe "Server reachability:" do
	setup do
	user = insert(:user)
	remote_user = insert(:user, local: false, ap_id: "https://example.com/users/remote")
	{:ok, _, _} = Pleroma.User.follow(user, remote_user)
	- {:ok, activity} = CommonAPI.post(remote_user, %{status: "Test post"})
	+ {:ok, activity} = post_as_remote(remote_user, %{status: "Test post"})

	%{
	user: user,
	remote_user: remote_user,
	activity: activity
	}
	end

	test "schedules ReachabilityWorker if host is unreachable", %{activity: activity} do
	with_mocks [
	{Pleroma.Web.ActivityPub.Transmogrifier, [],
	[handle_incoming: fn _ -> {:ok, activity} end]},
	{Pleroma.Instances, [], [reachable?: fn _ -> false end]},
	{Pleroma.Web.Federator, [], [perform: fn :incoming_ap_doc, _params -> {:ok, nil} end]}
	] do
	job = %Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => activity.data
	}
	}

	Pleroma.Workers.ReceiverWorker.perform(job)

	assert_enqueued(
	worker: Pleroma.Workers.ReachabilityWorker,
	args: %{"domain" => "example.com"}
	)
	end
	end

	test "does not schedule ReachabilityWorker if host is reachable", %{activity: activity} do
	with_mocks [
	{Pleroma.Web.ActivityPub.Transmogrifier, [],
	[handle_incoming: fn _ -> {:ok, activity} end]},
	{Pleroma.Instances, [], [reachable?: fn _ -> true end]},
	{Pleroma.Web.Federator, [], [perform: fn :incoming_ap_doc, _params -> {:ok, nil} end]}
	] do
	job = %Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => activity.data
	}
	}

	Pleroma.Workers.ReceiverWorker.perform(job)

	refute_enqueued(worker: Pleroma.Workers.ReachabilityWorker)
	end
	end
	end
	end
	diff --git a/test/support/helpers.ex b/test/support/helpers.ex
	index 7fa6c31a4..5fbc42699 100644
	--- a/test/support/helpers.ex
	+++ b/test/support/helpers.ex
	@@ -1,171 +1,192 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Tests.Helpers do
	@moduledoc """
	Helpers for use in tests.
	"""
	alias Pleroma.Config

	require Logger

	+ @doc """
	+ Creates a post for a user whose `ap_id` is on another host, as if it had
	+ been received from that host. `CommonAPI.post/2` only works for local users,
	+ since the pipeline validates that the actor and the object share a host.
	+ """
	+ def post_as_remote(%Pleroma.User{ap_id: ap_id} = user, params) do
	+ %URI{scheme: scheme, host: host} = URI.parse(ap_id)
	+ base = "#{scheme}://#{host}"
	+
	+ with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, params),
	+ changes =
	+ draft.changes
	+ \|> Map.put("id", "#{base}/activities/#{Ecto.UUID.generate()}")
	+ \|> put_in(["object", "id"], "#{base}/objects/#{Ecto.UUID.generate()}"),
	+ {:ok, activity, _meta} <-
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(changes, local: false) do
	+ {:ok, activity}
	+ end
	+ end
	+
	@doc "Accepts two URLs/URIs and sorts the query parameters before comparing"
	def uri_equal?(a, b) do
	a_sorted = uri_query_sort(a)
	b_sorted = uri_query_sort(b)

	match?(^a_sorted, b_sorted)
	end

	@doc "Accepts a URL/URI and sorts the query parameters"
	def uri_query_sort(uri) do
	parsed = URI.parse(uri)

	sorted_query =
	String.split(parsed.query, "&")
	\|> Enum.sort()
	\|> Enum.join("&")

	parsed
	\|> Map.put(:query, sorted_query)
	\|> URI.to_string()
	end

	@doc "Returns the value of the specified query parameter for the provided URL"
	def get_query_parameter(url, param) do
	url
	\|> URI.parse()
	\|> Map.get(:query)
	\|> URI.query_decoder()
	\|> Enum.to_list()
	\|> Enum.into(%{}, fn {x, y} -> {x, y} end)
	\|> Map.get(param)
	end

	defmacro clear_config(config_path) do
	quote do
	clear_config(unquote(config_path)) do
	end
	end
	end

	defmacro clear_config(config_path, do: yield) do
	quote do
	initial_setting = Config.fetch(unquote(config_path))

	unquote(yield)

	on_exit(fn ->
	case initial_setting do
	:error ->
	Config.delete(unquote(config_path))

	{:ok, value} ->
	Config.put(unquote(config_path), value)
	end
	end)

	:ok
	end
	end

	defmacro clear_config(config_path, temp_setting) do
	# NOTE: `clear_config([section, key], value)` != `clear_config([section], key: value)` (!)
	# Displaying a warning to prevent unintentional clearing of all but one keys in section
	if Keyword.keyword?(temp_setting) and length(temp_setting) == 1 do
	Logger.warning(
	"Please change `clear_config([section], key: value)` to `clear_config([section, key], value)`"
	)
	end

	quote do
	clear_config(unquote(config_path)) do
	Config.put(unquote(config_path), unquote(temp_setting))
	end
	end
	end

	def require_migration(migration_name) do
	[{module, _}] = Code.require_file("#{migration_name}.exs", "priv/repo/migrations")
	{:ok, %{migration: module}}
	end

	defmacro __using__(_opts) do
	quote do
	import Pleroma.Tests.Helpers,
	only: [
	clear_config: 1,
	- clear_config: 2
	+ clear_config: 2,
	+ post_as_remote: 2
	]

	def time_travel(entity, seconds) do
	new_time = NaiveDateTime.add(entity.inserted_at, seconds)

	entity
	\|> Ecto.Changeset.change(%{inserted_at: new_time, updated_at: new_time})
	\|> Pleroma.Repo.update()
	end

	def to_datetime(%NaiveDateTime{} = naive_datetime) do
	naive_datetime
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.truncate(:second)
	end

	def to_datetime(datetime) when is_binary(datetime) do
	datetime
	\|> NaiveDateTime.from_iso8601!()
	\|> to_datetime()
	end

	def collect_ids(collection) do
	collection
	\|> Enum.map(& &1.id)
	\|> Enum.sort()
	end

	def refresh_record(%{id: id, __struct__: model} = _),
	do: refresh_record(model, %{id: id})

	def refresh_record(model, %{id: id} = _) do
	Pleroma.Repo.get_by(model, id: id)
	end

	# Used for comparing json rendering during tests.
	def render_json(view, template, assigns) do
	assigns = Map.new(assigns)

	view.render(template, assigns)
	\|> Jason.encode!()
	\|> Jason.decode!()
	end

	def stringify_keys(nil), do: nil

	def stringify_keys(key) when key in [true, false], do: key
	def stringify_keys(key) when is_atom(key), do: Atom.to_string(key)

	def stringify_keys(map) when is_map(map) do
	map
	\|> Enum.map(fn {k, v} -> {stringify_keys(k), stringify_keys(v)} end)
	\|> Enum.into(%{})
	end

	def stringify_keys([head \| rest] = list) when is_list(list) do
	[stringify_keys(head) \| stringify_keys(rest)]
	end

	def stringify_keys(key), do: key

	defmacro guards_config(config_path) do
	quote do
	initial_setting = Config.get(config_path)

	Config.put(config_path, true)
	on_exit(fn -> Config.put(config_path, initial_setting) end)
	end
	end
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 1:11 AM (18 h, 58 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768582
Default Alt Text: (759 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions