No OneTemporary
Actions

Size

354 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.gitignore b/.gitignore
	index 355cea069..d8e5ed553 100644
	--- a/.gitignore
	+++ b/.gitignore
	@@ -1,68 +1,71 @@
	# App artifacts
	/_build
	/db
	/deps
	/*.ez
	/test/instance
	/test/uploads
	/.elixir_ls
	/test/fixtures/DSCN0010_tmp*
	/test/fixtures/test_tmp.txt
	/test/fixtures/image_tmp.jpg
	/test/tmp/
	/doc
	/instance
	/priv/ssh_keys

	# Prevent committing custom emojis
	/priv/static/emoji/custom/*

	# Generated on crash by the VM
	erl_crash.dump

	# Files matching config/*.secret.exs pattern contain sensitive
	# data and you should not commit them into version control.
	#
	# Alternatively, you may comment the line below and commit the
	# secrets files as long as you replace their contents by environment
	# variables.
	/config/*.secret.exs
	/config/generated_config.exs
	/config/runtime.exs
	/config/*.env


	# Database setup file, some may forget to delete it
	/config/setup_db*.psql

	.DS_Store
	.env

	# Editor config
	/.vscode/

	# Prevent committing docs files
	/priv/static/doc/*
	docs/generated_config.md

	# Code test coverage
	/cover
	/Elixir.*.coverdata
	/coverage.xml

	.idea
	pleroma.iml

	# asdf
	.tool-versions

	+# mise
	+mise.toml
	+
	# Editor temp files
	*~
	*#
	*.swp

	archive-*
	.gitlab-ci-local

	# Test files should be named *.exs
	test/pleroma/*/.ex
	diff --git a/.woodpecker/lint.yaml b/.woodpecker/lint.yaml
	index 7b2a1683c..0ab7441a8 100644
	--- a/.woodpecker/lint.yaml
	+++ b/.woodpecker/lint.yaml
	@@ -1,77 +1,77 @@
	when:
	- event: pull_request
	- path: [ ".ex", ".eex", ".exs", "mix.lock", ".woodpecker/*" ]
	+ path: [ "*/.ex", "*/.eex", "*/.exs", "mix.lock", ".woodpecker/**" ]
	- event: push
	branch: ${CI_REPO_DEFAULT_BRANCH}
	- path: [ ".ex", ".eex", ".exs", "mix.lock", ".woodpecker/*" ]
	+ path: [ "*/.ex", "*/.eex", "*/.exs", "mix.lock", ".woodpecker/**" ]

	labels:
	platform: linux/amd64

	variables:
	script_file_entrypoint: &script_file_entrypoint
	- /bin/sh
	- -c
	- 'printf "%s" "$CI_SCRIPT" \| base64 -d > /tmp/ci-script.sh && /bin/sh -xe /tmp/ci-script.sh'

	steps:
	mix-format:
	image: &elixir-image
	docker.io/elixir:1.15-alpine
	entrypoint: *script_file_entrypoint
	failure: ignore
	commands:
	- \|
	if ! mix format --check-formatted; then
	touch fail.stamp
	exit 1
	fi

	credo:
	image: *elixir-image
	entrypoint: *script_file_entrypoint
	failure: ignore
	environment:
	MIX_ENV: test
	commands:
	- apk add --no-cache build-base cmake exiftool ffmpeg file-dev git openssl
	- adduser -D -h /home/testuser testuser
	- mkdir -p /home/testuser/.mix /home/testuser/.hex
	- chown -R testuser:testuser . /home/testuser
	- su testuser -c "HOME=/home/testuser mix local.hex --force"
	- su testuser -c "HOME=/home/testuser mix local.rebar --force"
	- su testuser -c "HOME=/home/testuser mix deps.get"
	- \|
	if ! su testuser -c "HOME=/home/testuser mix analyze"; then
	touch fail.stamp
	exit 1
	fi

	# cycles:
	# image: *elixir-image
	# failure: ignore
	# commands:
	# - apk add --no-cache build-base cmake exiftool ffmpeg file-dev git openssl
	# - adduser -D -h /home/testuser testuser
	# - mkdir -p /home/testuser/.mix /home/testuser/.hex
	# - chown -R testuser:testuser . /home/testuser
	# - su testuser -c "HOME=/home/testuser mix local.hex --force"
	# - su testuser -c "HOME=/home/testuser mix local.rebar --force"
	# - su testuser -c "HOME=/home/testuser mix compile"
	# - \|
	# if ! su testuser -c "HOME=/home/testuser mix xref graph --format cycles --label compile \| awk '{print $0} END{exit ($0 != \"No cycles found\")}'"; then
	# touch fail.stamp
	# exit 1
	# fi

	ensure-status:
	image: *elixir-image
	entrypoint: *script_file_entrypoint
	commands: \|
	if test -f fail.stamp; then
	echo "One or more previous steps fails. Failing workflow..."
	exit 1
	else
	echo "All steps passed"
	exit 0
	fi
	diff --git a/.woodpecker/unit-testing-elixir-1.15.yaml b/.woodpecker/unit-testing-elixir-1.15.yaml
	index 5c6be764d..a4a8fc266 100644
	--- a/.woodpecker/unit-testing-elixir-1.15.yaml
	+++ b/.woodpecker/unit-testing-elixir-1.15.yaml
	@@ -1,44 +1,44 @@
	when:
	- event: pull_request
	- path: [ ".ex", ".eex", ".exs", "mix.lock", ".woodpecker/*" ]
	+ path: [ "*/.ex", "*/.eex", "*/.exs", "mix.lock", ".woodpecker/**" ]
	- event: push
	branch: ${CI_REPO_DEFAULT_BRANCH}
	- path: [ ".ex", ".eex", ".exs", "mix.lock", ".woodpecker/*" ]
	+ path: [ "*/.ex", "*/.eex", "*/.exs", "mix.lock", ".woodpecker/**" ]

	depends_on:
	- lint

	labels:
	platform: linux/amd64

	variables:
	script_file_entrypoint: &script_file_entrypoint
	- /bin/sh
	- -c
	- 'printf "%s" "$CI_SCRIPT" \| base64 -d > /tmp/ci-script.sh && /bin/sh -xe /tmp/ci-script.sh'

	steps:
	unit-testing-elixir-1.15:
	image: elixir:1.15-alpine
	entrypoint: *script_file_entrypoint
	environment:
	MIX_ENV: test
	DB_HOST: postgres
	DB_PORT: 5432
	commands:
	- apk add --no-cache build-base cmake exiftool ffmpeg file-dev git openssl
	- adduser -D -h /home/testuser testuser
	- mkdir -p /home/testuser/.mix /home/testuser/.hex
	- chown -R testuser:testuser . /home/testuser
	- su testuser -c "HOME=/home/testuser mix local.hex --force"
	- su testuser -c "HOME=/home/testuser mix local.rebar --force"
	- su testuser -c "HOME=/home/testuser mix deps.get"
	- su testuser -c "HOME=/home/testuser mix pleroma.test_runner --preload-modules"

	services:
	postgres:
	image: postgres:13-alpine
	environment:
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	diff --git a/.woodpecker/unit-testing-elixir-1.18.yaml b/.woodpecker/unit-testing-elixir-1.18.yaml
	index 2a40f41f7..9ad9eebc9 100644
	--- a/.woodpecker/unit-testing-elixir-1.18.yaml
	+++ b/.woodpecker/unit-testing-elixir-1.18.yaml
	@@ -1,44 +1,44 @@
	when:
	- event: pull_request
	- path: [ ".ex", ".eex", ".exs", "mix.lock", ".woodpecker/*" ]
	+ path: [ "*/.ex", "*/.eex", "*/.exs", "mix.lock", ".woodpecker/**" ]
	- event: push
	branch: ${CI_REPO_DEFAULT_BRANCH}
	- path: [ ".ex", ".eex", ".exs", "mix.lock", ".woodpecker/*" ]
	+ path: [ "*/.ex", "*/.eex", "*/.exs", "mix.lock", ".woodpecker/**" ]

	depends_on:
	- lint

	labels:
	platform: linux/amd64

	variables:
	script_file_entrypoint: &script_file_entrypoint
	- /bin/sh
	- -c
	- 'printf "%s" "$CI_SCRIPT" \| base64 -d > /tmp/ci-script.sh && /bin/sh -xe /tmp/ci-script.sh'

	steps:
	unit-testing-elixir-1.18:
	image: elixir:1.18-otp-27-alpine
	entrypoint: *script_file_entrypoint
	environment:
	MIX_ENV: test
	DB_HOST: postgres
	DB_PORT: 5432
	commands:
	- apk add --no-cache build-base cmake exiftool ffmpeg file-dev git openssl
	- adduser -D -h /home/testuser testuser
	- mkdir -p /home/testuser/.mix /home/testuser/.hex
	- chown -R testuser:testuser . /home/testuser
	- su testuser -c "HOME=/home/testuser mix local.hex --force"
	- su testuser -c "HOME=/home/testuser mix local.rebar --force"
	- su testuser -c "HOME=/home/testuser mix deps.get"
	- su testuser -c "HOME=/home/testuser mix pleroma.test_runner --preload-modules"

	services:
	postgres:
	image: postgres:13-alpine
	environment:
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	diff --git a/changelog.d/activitypub-spoofing.security b/changelog.d/activitypub-spoofing.security
	new file mode 100644
	index 000000000..3e6baffb6
	--- /dev/null
	+++ b/changelog.d/activitypub-spoofing.security
	@@ -0,0 +1 @@
	+ActivityPub: Fixed failed-signature inbox retry handling and signer identity checks to prevent spoofed remote activities from being processed
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 071d634db..0b513ee16 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1943 +1,1981 @@
	# 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

	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(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),
	: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)
	end

	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(: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, %{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
	from(
	[_activity, object] in query,
	join: hto in "hashtags_objects",
	on: hto.object_id == object.id,
	where: hto.hashtag_id in ^hashtag_ids,
	distinct: [desc: object.id],
	order_by: [desc: object.id]
	)
	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_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
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_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_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)
	\|> 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_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

	- # if WebFinger request was already done, we probably have acct, otherwise
	- # we request WebFinger here
	- nickname = additional[:nickname_from_acct] \|\| generate_nickname(data)
	+ 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

	- %{
	- 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
	- }
	+ 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 = "#{username}@#{URI.parse(data["id"]).host}"
	+ generated = generated_nickname(data)

	if Config.get([WebFinger, :update_nickname_on_user_fetch]) do
	- case WebFinger.finger(generated) do
	- {:ok, %{"subject" => "acct:" <> acct}} -> acct
	+ 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) do
	- {:ok, object_to_user_data(data, additional)}
	+ 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

	def pin_data_from_featured_collection(%{
	"type" => type,
	"orderedItems" => objects
	})
	when type in ["OrderedCollection", "Collection"] 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, pin_data_from_featured_collection(data)}
	else
	e ->
	Logger.error("Could not decode featured collection at fetch #{ap_id}, #{inspect(e)}")
	{:ok, %{}}
	end
	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/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index 4f1613a07..2bfff6968 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,643 +1,643 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	require Logger

	action_fallback(:errors)

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

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

	plug(FederatingPlug when action in @federating_only_actions)

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

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

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

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

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

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

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

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

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

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

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

	def track_object_fetch(conn, nil), do: conn

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

	conn
	end

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

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

	defp maybe_set_tracking_data(conn, _activity), do: conn

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

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

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

	_ ->
	nil
	end

	assign(conn, :cache_ttl, ttl)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end

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

	json(conn, "ok")
	end

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

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

	defp post_inbox_relayed_create(conn, params) do
	Logger.debug(
	"Signature missing or not from author, relayed Create message, fetching object from source"
	)

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

	json(conn, "ok")
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	defp log_inbox_metadata(conn, _), do: conn

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

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

	def pinned(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("featured.json", %{user: user}))
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/update_validator.ex b/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	index aab90235f..4c0d9dff7 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	@@ -1,93 +1,118 @@
	# 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.UpdateValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

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

	field(:actor, ObjectValidators.ObjectID)
	# In this case, we save the full object in this activity instead of just a
	# reference, so we can always see what was actually changed by this.
	field(:object, :map)
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(cng, meta) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Update"])
	\|> validate_actor_presence()
	\|> validate_updating_rights(meta)
	end

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

	def validate_updating_rights(cng, meta) do
	if meta[:local] do
	validate_updating_rights_local(cng)
	else
	validate_updating_rights_remote(cng)
	end
	end

	# For local Updates, verify the actor can edit the object
	def validate_updating_rights_local(cng) do
	actor = get_field(cng, :actor)
	updated_object = get_field(cng, :object)

	if {:ok, actor} == ObjectValidators.ObjectID.cast(updated_object) do
	cng
	else
	with %User{} = user <- User.get_cached_by_ap_id(actor),
	{_, %Object{} = orig_object} <- {:object, Object.normalize(updated_object)},
	:ok <- Object.authorize_access(orig_object, user) do
	cng
	else
	_e ->
	cng
	\|> add_error(:object, "Can't be updated by this actor")
	end
	end
	end

	- # For remote Updates, verify the host is the same.
	+ # For remote Updates, verify the Actor is the same
	def validate_updating_rights_remote(cng) do
	with actor = get_field(cng, :actor),
	object = get_field(cng, :object),
	{:ok, object_id} <- ObjectValidators.ObjectID.cast(object),
	- actor_uri <- URI.parse(actor),
	- object_uri <- URI.parse(object_id),
	- true <- actor_uri.host == object_uri.host do
	- cng
	+ entity <-
	+ Object.normalize(object_id, fetch: false) \|\| User.get_cached_by_ap_id(object_id) do
	+ case entity do
	+ # Actor must own Object to update it
	+ %Object{} ->
	+ if actor == entity.data["actor"] do
	+ cng
	+ else
	+ cng
	+ \|> add_error(:object, "Can't be updated by this actor")
	+ end
	+
	+ # Actor must only be allowed to update itself
	+ %User{} ->
	+ if actor == entity.ap_id do
	+ cng
	+ else
	+ cng
	+ \|> add_error(:object, "Can't be updated by this actor")
	+ end
	+
	+ nil ->
	+ cng
	+ \|> add_error(:object, "Can't be updated by this actor")
	+
	+ _ ->
	+ cng
	+ \|> add_error(:object, "Update is neither for Object or Actor")
	+ end
	else
	_e ->
	cng
	\|> add_error(:object, "Can't be updated by this actor")
	end
	end
	end
	diff --git a/lib/pleroma/web/federator.ex b/lib/pleroma/web/federator.ex
	index 676fc5137..90cd2e54a 100644
	--- a/lib/pleroma/web/federator.ex
	+++ b/lib/pleroma/web/federator.ex
	@@ -1,135 +1,145 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Federator do
	alias Pleroma.Activity
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Workers.PublisherWorker
	alias Pleroma.Workers.ReceiverWorker
	+ alias Pleroma.Workers.SignatureRetryWorker

	require Logger

	@behaviour Pleroma.Web.Federator.Publishing

	@doc """
	Returns `true` if the distance to target object does not exceed max configured value.
	Serves to prevent fetching of very long threads, especially useful on smaller instances.
	Addresses [memory leaks on recursive replies fetching](https://git.pleroma.social/pleroma/pleroma/issues/161).
	Applies to fetching of both ancestor (reply-to) and child (reply) objects.
	"""
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	def allowed_thread_distance?(distance) do
	max_distance = Pleroma.Config.get([:instance, :federation_incoming_replies_max_depth])

	if max_distance && max_distance >= 0 do
	# Default depth is 0 (an object has zero distance from itself in its thread)
	(distance \|\| 0) <= max_distance
	else
	true
	end
	end

	# Client API
	- def incoming_ap_doc(%{params: params, req_headers: req_headers}) do
	- ReceiverWorker.new(
	+ def incoming_failed_signature_ap_doc(%{
	+ method: method,
	+ params: params,
	+ req_headers: req_headers,
	+ request_path: request_path,
	+ query_string: query_string
	+ }) do
	+ SignatureRetryWorker.new(
	%{
	- "op" => "incoming_ap_doc",
	+ "op" => "incoming_failed_signature_ap_doc",
	+ "method" => method,
	"req_headers" => req_headers,
	"params" => params,
	+ "request_path" => request_path,
	+ "query_string" => query_string,
	"timeout" => :timer.seconds(20)
	},
	priority: 2
	)
	\|> Oban.insert()
	end

	def incoming_ap_doc(%{"type" => "Delete"} = params) do
	ReceiverWorker.new(%{"op" => "incoming_ap_doc", "params" => params},
	priority: 3,
	queue: :slow
	)
	\|> Oban.insert()
	end

	def incoming_ap_doc(params) do
	ReceiverWorker.new(%{"op" => "incoming_ap_doc", "params" => params})
	\|> Oban.insert()
	end

	@impl true
	def publish(%{id: "pleroma:fakeid"} = activity) do
	perform(:publish, activity)
	end

	@impl true
	def publish(%Pleroma.Activity{data: %{"type" => type}} = activity) do
	PublisherWorker.new(%{"op" => "publish", "activity_id" => activity.id},
	priority: publish_priority(type)
	)
	\|> Oban.insert()
	end

	defp publish_priority("Delete"), do: 3
	defp publish_priority(_), do: 0

	# Job Worker Callbacks

	@spec perform(atom(), any()) :: {:ok, any()} \| {:error, any()}
	def perform(:publish_one, params) do
	Publisher.prepare_one(params)
	\|> Publisher.publish_one()
	end

	def perform(:publish, activity) do
	Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)

	%User{} = actor = User.get_cached_by_ap_id(activity.data["actor"])
	Publisher.publish(actor, activity)
	end

	def perform(:incoming_ap_doc, params) do
	Logger.debug("Handling incoming AP activity")

	actor =
	params
	\|> Map.get("actor")
	\|> Utils.get_ap_id()

	# NOTE: we use the actor ID to do the containment, this is fine because an
	# actor shouldn't be acting on objects outside their own AP server.
	with {_, {:ok, user}} <- {:actor, User.get_or_fetch_by_ap_id(actor)},
	{:user_active, true} <- {:user_active, match?(true, user.is_active)},
	nil <- Activity.normalize(params["id"]),
	{_, :ok} <-
	{:correct_origin?, Containment.contain_origin_from_id(actor, params)},
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, activity}
	else
	{:correct_origin?, _} ->
	Logger.debug("Origin containment failure for #{params["id"]}")
	{:error, :origin_containment_failed}

	%Activity{} ->
	Logger.debug("Already had #{params["id"]}")
	{:error, :already_present}

	{:actor, e} ->
	Logger.debug("Unhandled actor #{actor}, #{inspect(e)}")
	{:error, e}

	{:reject, reason} = e ->
	Logger.debug("Rejected by MRF: #{inspect(reason)}")
	{:error, e}

	e ->
	# Just drop those for now
	Logger.debug(fn -> "Unhandled activity\n" <> Jason.encode!(params, pretty: true) end)
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/plugs/mapped_signature_to_identity_plug.ex b/lib/pleroma/web/plugs/mapped_signature_to_identity_plug.ex
	index c6d531086..a688b1780 100644
	--- a/lib/pleroma/web/plugs/mapped_signature_to_identity_plug.ex
	+++ b/lib/pleroma/web/plugs/mapped_signature_to_identity_plug.ex
	@@ -1,76 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.MappedSignatureToIdentityPlug do
	alias Pleroma.Helpers.AuthHelper
	alias Pleroma.Signature
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils

	import Plug.Conn
	require Logger

	def init(options), do: options

	def call(%{assigns: %{user: %User{}}} = conn, _opts), do: conn

	# if this has payload make sure it is signed by the same actor that made it
	def call(%{assigns: %{valid_signature: true}, params: %{"actor" => actor}} = conn, _opts) do
	with actor_id <- Utils.get_ap_id(actor),
	{:user, %User{} = user} <- {:user, user_from_key_id(conn)},
	{:user_match, true} <- {:user_match, user.ap_id == actor_id} do
	conn
	\|> assign(:user, user)
	\|> AuthHelper.skip_oauth()
	else
	{:user_match, false} ->
	Logger.debug("Failed to map identity from signature (payload actor mismatch)")
	Logger.debug("key_id=#{inspect(key_id_from_conn(conn))}, actor=#{inspect(actor)}")
	assign(conn, :valid_signature, false)

	# remove me once testsuite uses mapped capabilities instead of what we do now
	{:user, nil} ->
	Logger.debug("Failed to map identity from signature (lookup failure)")
	- Logger.debug("key_id=#{inspect(key_id_from_conn(conn))}, actor=#{actor}")
	- conn
	+ Logger.debug("key_id=#{inspect(key_id_from_conn(conn))}, actor=#{inspect(actor)}")
	+ assign(conn, :valid_signature, false)
	end
	end

	# no payload, probably a signed fetch
	def call(%{assigns: %{valid_signature: true}} = conn, _opts) do
	with %User{} = user <- user_from_key_id(conn) do
	conn
	\|> assign(:user, user)
	\|> AuthHelper.skip_oauth()
	else
	_ ->
	Logger.debug("Failed to map identity from signature (no payload actor mismatch)")
	Logger.debug("key_id=#{inspect(key_id_from_conn(conn))}")
	assign(conn, :valid_signature, false)
	end
	end

	# no signature at all
	def call(conn, _opts), do: conn

	defp key_id_from_conn(conn) do
	with %{"keyId" => key_id} <- HTTPSignatures.signature_for_conn(conn),
	{:ok, ap_id} <- Signature.key_id_to_actor_id(key_id) do
	ap_id
	else
	_ ->
	nil
	end
	end

	defp user_from_key_id(conn) do
	with key_actor_id when is_binary(key_actor_id) <- key_id_from_conn(conn),
	{:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(key_actor_id) do
	user
	else
	_ ->
	nil
	end
	end
	end
	diff --git a/lib/pleroma/workers/receiver_worker.ex b/lib/pleroma/workers/receiver_worker.ex
	index e2c950967..3afbe138d 100644
	--- a/lib/pleroma/workers/receiver_worker.ex
	+++ b/lib/pleroma/workers/receiver_worker.ex
	@@ -1,97 +1,87 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.ReceiverWorker do
	alias Pleroma.Instances
	- alias Pleroma.Signature
	- alias Pleroma.User
	alias Pleroma.Web.Federator
	+ alias Pleroma.Workers.SignatureRetryWorker

	use Oban.Worker, queue: :federator_incoming, max_attempts: 5, unique: [period: :infinity]

	@impl true
	+ def perform(%Job{args: %{"op" => "incoming_ap_doc", "params" => params} = args} = job) do
	+ if signature_retry_job?(args) do
	+ perform_signature_retry(job)
	+ else
	+ perform_incoming(params)
	+ end
	+ end

	- def perform(%Job{
	- args: %{
	- "op" => "incoming_ap_doc",
	- "method" => method,
	- "params" => params,
	- "req_headers" => req_headers,
	- "request_path" => request_path,
	- "query_string" => query_string
	- }
	- }) do
	- # Oban's serialization converts our tuple headers to lists.
	- # Revert it for the signature validation.
	- req_headers = Enum.into(req_headers, [], &List.to_tuple(&1))
	-
	- conn_data = %Plug.Conn{
	- method: method,
	- params: params,
	- req_headers: req_headers,
	- request_path: request_path,
	- query_string: query_string
	- }
	-
	- with {:ok, %User{}} <- User.get_or_fetch_by_ap_id(conn_data.params["actor"]),
	- {:ok, _public_key} <- Signature.refetch_public_key(conn_data),
	- {:signature, true} <- {:signature, Signature.validate_signature(conn_data)},
	- {:ok, res} <- Federator.perform(:incoming_ap_doc, params) do
	- unless Instances.reachable?(params["actor"]) do
	- domain = URI.parse(params["actor"]).host
	- Oban.insert(Pleroma.Workers.ReachabilityWorker.new(%{"domain" => domain}))
	- end
	-
	- {:ok, res}
	+ def perform(%Job{args: %{"op" => "incoming_ap_doc"} = args} = job) do
	+ if signature_retry_job?(args) do
	+ perform_signature_retry(job)
	else
	- e -> process_errors(e)
	+ process_errors(:missing_incoming_ap_doc_params)
	end
	end

	- def perform(%Job{args: %{"op" => "incoming_ap_doc", "params" => params}}) do
	+ defp perform_signature_retry(%Job{args: args} = job) do
	+ SignatureRetryWorker.perform(%Job{
	+ job
	+ \| args: Map.put(args, "op", "incoming_failed_signature_ap_doc")
	+ })
	+ end
	+
	+ defp perform_incoming(params) do
	with {:ok, res} <- Federator.perform(:incoming_ap_doc, params) do
	unless Instances.reachable?(params["actor"]) do
	domain = URI.parse(params["actor"]).host
	Oban.insert(Pleroma.Workers.ReachabilityWorker.new(%{"domain" => domain}))
	end

	{:ok, res}
	else
	e -> process_errors(e)
	end
	end

	+ defp signature_retry_job?(args) do
	+ Enum.any?(~w(method req_headers request_path query_string), &Map.has_key?(args, &1))
	+ end
	+
	@impl true
	def timeout(%_{args: %{"timeout" => timeout}}), do: timeout

	def timeout(_job), do: :timer.seconds(5)

	defp process_errors({:error, {:error, _} = error}), do: process_errors(error)

	defp process_errors(errors) do
	case errors do
	# User fetch failures
	{:error, :not_found} = reason -> {:cancel, reason}
	{:error, :forbidden} = reason -> {:cancel, reason}
	# Inactive user
	{:error, {:user_active, false} = reason} -> {:cancel, reason}
	# Validator will error and return a changeset error
	# e.g., duplicate activities or if the object was deleted
	{:error, {:validate, {:error, _changeset} = reason}} -> {:cancel, reason}
	# Duplicate detection during Normalization
	{:error, :already_present} -> {:cancel, :already_present}
	# MRFs will return a reject
	{:error, {:reject, _} = reason} -> {:cancel, reason}
	# HTTP Sigs
	{:signature, false} -> {:cancel, :invalid_signature}
	+ {:same_actor, false} -> {:cancel, :actor_signature_mismatch}
	# Origin / URL validation failed somewhere possibly due to spoofing
	{:error, :origin_containment_failed} -> {:cancel, :origin_containment_failed}
	# Unclear if this can be reached
	{:error, {:side_effects, {:error, :no_object_actor}} = reason} -> {:cancel, reason}
	+ :missing_incoming_ap_doc_params -> {:cancel, :missing_incoming_ap_doc_params}
	# Catchall
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/workers/signature_retry_worker.ex b/lib/pleroma/workers/signature_retry_worker.ex
	new file mode 100644
	index 000000000..2c4c097dd
	--- /dev/null
	+++ b/lib/pleroma/workers/signature_retry_worker.ex
	@@ -0,0 +1,254 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Workers.SignatureRetryWorker do
	+ alias Pleroma.Instances
	+ alias Pleroma.Signature
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Utils
	+ alias Pleroma.Web.Federator
	+ alias Pleroma.Web.Plugs.MappedSignatureToIdentityPlug
	+
	+ require Logger
	+
	+ use Oban.Worker, queue: :federator_incoming, max_attempts: 5, unique: [period: :infinity]
	+
	+ @impl true
	+ def perform(%Job{
	+ args: %{
	+ "op" => "incoming_failed_signature_ap_doc",
	+ "method" => method,
	+ "params" => params,
	+ "req_headers" => req_headers,
	+ "request_path" => request_path,
	+ "query_string" => query_string
	+ }
	+ })
	+ when is_binary(method) and is_map(params) and is_list(req_headers) and
	+ is_binary(request_path) and is_binary(query_string) do
	+ case normalize_req_headers(req_headers) do
	+ {:ok, req_headers} ->
	+ conn_data = %Plug.Conn{
	+ assigns: %{valid_signature: true},
	+ method: method,
	+ params: params,
	+ req_headers: req_headers,
	+ request_path: request_path,
	+ query_string: query_string
	+ }
	+
	+ signature_actor_result = signature_actor_id(conn_data)
	+
	+ with actor_id = Utils.get_ap_id(params["actor"]),
	+ {:signature_actor, {:ok, signature_actor_id}} <-
	+ {:signature_actor, signature_actor_result},
	+ {:same_actor, true} <- {:same_actor, signature_actor_id == actor_id},
	+ {:ok, %User{}} <- User.get_or_fetch_by_ap_id(actor_id),
	+ {:ok, _public_key} <- Signature.refetch_public_key(conn_data),
	+ {:signature, true} <- {:signature, validate_signature(conn_data)},
	+ {:same_actor, true} <- {:same_actor, validate_same_actor(conn_data)},
	+ {:ok, res} <- Federator.perform(:incoming_ap_doc, params) do
	+ unless Instances.reachable?(params["actor"]) do
	+ domain = URI.parse(params["actor"]).host
	+ Oban.insert(Pleroma.Workers.ReachabilityWorker.new(%{"domain" => domain}))
	+ end
	+
	+ {:ok, res}
	+ else
	+ e -> process_errors(e, retry_log_context(params, request_path, signature_actor_result))
	+ end
	+
	+ e ->
	+ process_errors(e, retry_log_context(params, request_path, nil))
	+ end
	+ end
	+
	+ def perform(%Job{args: %{"op" => "incoming_failed_signature_ap_doc"} = args}) do
	+ process_errors(
	+ :missing_signature_retry_metadata,
	+ retry_log_context(Map.get(args, "params"), Map.get(args, "request_path"), nil)
	+ )
	+ end
	+
	+ def perform(%Job{args: args}) when is_map(args) do
	+ process_errors(
	+ :missing_signature_retry_metadata,
	+ retry_log_context(Map.get(args, "params"), Map.get(args, "request_path"), nil)
	+ )
	+ end
	+
	+ def perform(%Job{}), do: process_errors(:missing_signature_retry_metadata)
	+
	+ @impl true
	+ def timeout(%_{args: %{"timeout" => timeout}}), do: timeout
	+
	+ def timeout(_job), do: :timer.seconds(5)
	+
	+ defp normalize_req_headers(req_headers) do
	+ req_headers
	+ \|> Enum.reduce_while({:ok, []}, fn
	+ {key, value}, {:ok, acc} when is_binary(key) and is_binary(value) ->
	+ {:cont, {:ok, [{key, value} \| acc]}}
	+
	+ [key, value], {:ok, acc} when is_binary(key) and is_binary(value) ->
	+ {:cont, {:ok, [{key, value} \| acc]}}
	+
	+ _, _ ->
	+ {:halt, {:error, :invalid_signature_retry_metadata}}
	+ end)
	+ \|> case do
	+ {:ok, headers} -> {:ok, Enum.reverse(headers)}
	+ error -> error
	+ end
	+ end
	+
	+ defp validate_same_actor(conn_data) do
	+ case MappedSignatureToIdentityPlug.call(conn_data, []) do
	+ %Plug.Conn{assigns: %{valid_signature: true}} ->
	+ true
	+
	+ _ ->
	+ false
	+ end
	+ end
	+
	+ defp validate_signature(conn_data) do
	+ Signature.validate_signature(conn_data)
	+ rescue
	+ _ -> false
	+ catch
	+ _, _ -> false
	+ end
	+
	+ defp signature_actor_id(conn_data) do
	+ Signature.get_actor_id(conn_data)
	+ rescue
	+ _ -> {:error, :invalid_signature}
	+ catch
	+ _, _ -> {:error, :invalid_signature}
	+ end
	+
	+ defp process_errors(errors, context \\ %{})
	+
	+ defp process_errors({:error, {:error, _} = error}, context), do: process_errors(error, context)
	+
	+ defp process_errors(errors, context) do
	+ result =
	+ case errors do
	+ # User fetch failures
	+ {:error, :not_found} = reason ->
	+ {:cancel, reason}
	+
	+ {:error, :forbidden} = reason ->
	+ {:cancel, reason}
	+
	+ # Inactive user
	+ {:error, {:user_active, false} = reason} ->
	+ {:cancel, reason}
	+
	+ # Validator will error and return a changeset error
	+ # e.g., duplicate activities or if the object was deleted
	+ {:error, {:validate, {:error, _changeset} = reason}} ->
	+ {:cancel, reason}
	+
	+ # Duplicate detection during Normalization
	+ {:error, :already_present} ->
	+ {:cancel, :already_present}
	+
	+ # MRFs will return a reject
	+ {:error, {:reject, _} = reason} ->
	+ {:cancel, reason}
	+
	+ # HTTP Sigs
	+ {:signature_actor, {:error, _}} ->
	+ {:cancel, :invalid_signature}
	+
	+ {:signature, false} ->
	+ {:cancel, :invalid_signature}
	+
	+ {:same_actor, false} ->
	+ {:cancel, :actor_signature_mismatch}
	+
	+ # Origin / URL validation failed somewhere possibly due to spoofing
	+ {:error, :origin_containment_failed} ->
	+ {:cancel, :origin_containment_failed}
	+
	+ # Unclear if this can be reached
	+ {:error, {:side_effects, {:error, :no_object_actor}} = reason} ->
	+ {:cancel, reason}
	+
	+ # Fail closed if the retry cannot reconstruct the original request.
	+ :missing_signature_retry_metadata ->
	+ {:cancel, :missing_signature_retry_metadata}
	+
	+ {:error, :invalid_signature_retry_metadata} ->
	+ {:cancel, :invalid_signature_retry_metadata}
	+
	+ # Catchall
	+ {:error, _} = e ->
	+ e
	+
	+ e ->
	+ {:error, e}
	+ end
	+
	+ log_signature_retry_rejection(result, context)
	+ result
	+ end
	+
	+ defp retry_log_context(params, request_path, signature_actor_result) when is_map(params) do
	+ signature_actor =
	+ case signature_actor_result do
	+ {:ok, actor} when is_binary(actor) -> actor
	+ actor when is_binary(actor) -> actor
	+ _ -> nil
	+ end
	+
	+ %{
	+ activity_id: params["id"],
	+ payload_actor: Utils.get_ap_id(params["actor"]),
	+ request_path: request_path,
	+ signature_actor: signature_actor,
	+ type: params["type"]
	+ }
	+ end
	+
	+ defp retry_log_context(_params, request_path, signature_actor_result) do
	+ signature_actor =
	+ case signature_actor_result do
	+ {:ok, actor} when is_binary(actor) -> actor
	+ actor when is_binary(actor) -> actor
	+ _ -> nil
	+ end
	+
	+ %{
	+ activity_id: nil,
	+ payload_actor: nil,
	+ request_path: request_path,
	+ signature_actor: signature_actor,
	+ type: nil
	+ }
	+ end
	+
	+ defp log_signature_retry_rejection({:cancel, reason}, context)
	+ when reason in [
	+ :actor_signature_mismatch,
	+ :invalid_signature,
	+ :invalid_signature_retry_metadata,
	+ :missing_signature_retry_metadata,
	+ :origin_containment_failed
	+ ] do
	+ Logger.warning(
	+ "Failed-signature inbox retry rejected " <>
	+ "reason=#{inspect(reason)} " <>
	+ "payload_actor=#{inspect(context[:payload_actor])} " <>
	+ "signature_actor=#{inspect(context[:signature_actor])} " <>
	+ "activity_id=#{inspect(context[:activity_id])} " <>
	+ "type=#{inspect(context[:type])} " <>
	+ "request_path=#{inspect(context[:request_path])}"
	+ )
	+ end
	+
	+ defp log_signature_retry_rejection(_result, _context), do: :ok
	+end
	diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
	index b2533e9f1..de735cdb7 100644
	--- a/test/pleroma/user_test.exs
	+++ b/test/pleroma/user_test.exs
	@@ -1,3015 +1,3098 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Swoosh.TestAssertions

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

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

	setup do: clear_config([:instance, :account_activation_required])

	describe "service actors" do
	test "returns updated invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	insert(
	:user,
	%{
	nickname: "relay",
	invisible: false,
	local: true,
	ap_id: uri,
	follower_address: followers_uri
	}
	)

	actor = User.get_or_create_service_actor_by_ap_id(uri, "relay")
	assert actor.invisible
	end

	test "returns relay user" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	assert %User{
	nickname: "relay",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = User.get_or_create_service_actor_by_ap_id(uri, "relay")

	assert capture_log(fn ->
	refute User.get_or_create_service_actor_by_ap_id("/relay", "relay")
	end) =~ "Cannot create service actor:"
	end

	test "returns invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/internal/fetch-test"
	followers_uri = "#{uri}/followers"
	user = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")

	assert %User{
	nickname: "internal.fetch-test",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = user

	user2 = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
	assert user.id == user2.id
	end
	end

	describe "AP ID user relationships" do
	setup do
	{:ok, user: insert(:user)}
	end

	test "outgoing_relationships_ap_ids/1", %{user: user} do
	rel_types = [:block, :mute, :notification_mute, :reblog_mute, :inverse_subscription]

	ap_ids_by_rel =
	Enum.into(
	rel_types,
	%{},
	fn rel_type ->
	rel_records =
	insert_list(2, :user_relationship, %{source: user, relationship_type: rel_type})

	ap_ids = Enum.map(rel_records, fn rr -> Repo.preload(rr, :target).target.ap_id end)
	{rel_type, Enum.sort(ap_ids)}
	end
	)

	assert ap_ids_by_rel[:block] == Enum.sort(User.blocked_users_ap_ids(user))
	assert ap_ids_by_rel[:block] == Enum.sort(Enum.map(User.blocked_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:mute] == Enum.sort(User.muted_users_ap_ids(user))
	assert ap_ids_by_rel[:mute] == Enum.sort(Enum.map(User.muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(User.notification_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(Enum.map(User.notification_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:reblog_mute] == Enum.sort(User.reblog_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:reblog_mute] ==
	Enum.sort(Enum.map(User.reblog_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:inverse_subscription] == Enum.sort(User.subscriber_users_ap_ids(user))

	assert ap_ids_by_rel[:inverse_subscription] ==
	Enum.sort(Enum.map(User.subscriber_users(user), & &1.ap_id))

	outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)

	assert ap_ids_by_rel ==
	Enum.into(outgoing_relationships_ap_ids, %{}, fn {k, v} -> {k, Enum.sort(v)} end)
	end
	end

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "ap_following returns the following collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/following"

	assert expected_followers_collection == User.ap_following(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, is_locked: true)
	follower = insert(:user)

	CommonAPI.follow(unlocked, follower)
	CommonAPI.follow(locked, follower)

	assert [] = User.get_follow_requests(unlocked)
	assert [activity] = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, is_locked: true)
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	CommonAPI.follow(locked, pending_follower)
	CommonAPI.follow(locked, pending_follower)
	CommonAPI.follow(locked, accepted_follower)

	Pleroma.FollowingRelationship.update(accepted_follower, locked, :follow_accept)

	assert [^pending_follower] = User.get_follow_requests(locked)
	end

	test "doesn't return follow requests for deactivated accounts" do
	locked = insert(:user, is_locked: true)
	pending_follower = insert(:user, %{is_active: false})

	CommonAPI.follow(locked, pending_follower)

	refute pending_follower.is_active
	assert [] = User.get_follow_requests(locked)
	end

	test "clears follow requests when requester is blocked" do
	followed = insert(:user, is_locked: true)
	follower = insert(:user)

	CommonAPI.follow(followed, follower)
	assert [_activity] = User.get_follow_requests(followed)

	{:ok, _user_relationship} = User.block(followed, follower)
	assert [] = User.get_follow_requests(followed)
	end

	test "follow_all follows multiple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked)
	{:ok, _user_relationship} = User.block(reverse_blocked, user)

	{:ok, user, followed_zero} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows multiple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(User.following(user)) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(User.following(user)) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)
	followed = User.get_cached_by_ap_id(followed.ap_id)

	assert followed.follower_count == 1
	assert user.following_count == 1

	assert User.ap_followers(followed) in User.following(user)
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, %{is_active: false})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "can't subscribe to a user who blocked us" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	{:error, _} = User.subscribe(blocked, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, is_locked: true)
	followed = insert(:user, is_locked: true)

	{:ok, follower, followed} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	describe "unfollow/2" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "unfollow with synchronizes external user" do
	clear_config([:instance, :external_user_synchronization], true)

	followed =
	insert(:user,
	nickname: "fuser1",
	follower_address: "http://localhost:4001/users/fuser1/followers",
	following_address: "http://localhost:4001/users/fuser1/following",
	ap_id: "http://localhost:4001/users/fuser1"
	)

	user =
	insert(:user, %{
	local: false,
	nickname: "fuser2",
	ap_id: "http://localhost:4001/users/fuser2",
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	})

	{:ok, user, followed} = User.follow(user, followed, :follow_accept)

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert User.following(user) == []
	end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user)

	{:ok, user, followed} = User.follow(user, followed, :follow_accept)

	assert User.following(user) == [user.follower_address, followed.follower_address]

	{:ok, user, _activity} = User.unfollow(user, followed)

	assert User.following(user) == [user.follower_address]
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	assert User.following(user) == [user.follower_address]
	end
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user)
	User.follow(user, followed, :follow_accept)

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do: clear_config([:instance, :autofollowed_nicknames])
	setup do: clear_config([:instance, :autofollowing_nicknames])
	setup do: clear_config([:welcome])
	setup do: clear_config([:instance, :account_activation_required])

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	clear_config([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)
	end

	test "it adds automatic followers for new registered accounts" do
	user1 = insert(:user)
	user2 = insert(:user)

	clear_config([:instance, :autofollowing_nicknames], [
	user1.nickname,
	user2.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(user1, registered_user)
	assert User.following?(user2, registered_user)
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :direct_message, :enabled], true)
	clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :direct_message, :message], "Hello, this is a direct message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "direct message"
	assert activity.actor == welcome_user.ap_id
	end

	test "it sends a welcome chat message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :chat_message, :enabled], true)
	clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
	assert activity.actor == welcome_user.ap_id
	end

	setup do:
	clear_config(:mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []
	)

	setup do: clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])

	test "it sends a welcome chat message when Simple policy applied to local instance" do
	clear_config([:mrf_simple, :media_nsfw], [{"localhost", ""}])

	welcome_user = insert(:user)
	clear_config([:welcome, :chat_message, :enabled], true)
	clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
	assert activity.actor == welcome_user.ap_id
	end

	test "it sends a welcome email message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], welcome_user.email)

	clear_config(
	[:welcome, :email, :subject],
	"Hello, welcome to cool site: <%= instance_name %>"
	)

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

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	assert_email_sent(
	from: {instance_name, welcome_user.email},
	to: {registered_user.name, registered_user.email},
	subject: "Hello, welcome to cool site: #{instance_name}",
	html_body: "Welcome to #{instance_name}"
	)
	end

	test "it sends a confirm email" do
	clear_config([:instance, :account_activation_required], true)

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	Pleroma.Emails.UserEmail.account_confirmation_email(registered_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 "sends a pending approval email" do
	clear_config([:instance, :account_approval_required], true)

	{:ok, user} =
	User.register_changeset(%User{}, @full_user_data)
	\|> User.register()

	ObanHelpers.perform_all()

	assert_email_sent(
	from: Pleroma.Config.Helpers.sender(),
	to: {user.name, user.email},
	subject: "Your account is awaiting approval"
	)
	end

	test "it sends a registration confirmed email if no others will be sent" do
	clear_config([:welcome, :email, :enabled], false)
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], false)

	{:ok, user} =
	User.register_changeset(%User{}, @full_user_data)
	\|> User.register()

	ObanHelpers.perform_all()

	instance_name = Pleroma.Config.get([:instance, :name])
	sender = Pleroma.Config.get([:instance, :notify_email])

	assert_email_sent(
	from: {instance_name, sender},
	to: {user.name, user.email},
	subject: "Account registered on #{instance_name}"
	)
	end

	test "it fails gracefully with invalid email config" do
	cng = User.register_changeset(%User{}, @full_user_data)

	# Disable the mailer but enable all the things that want to send emails
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :account_approval_required], true)
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], "lain@lain.com")

	# The user is still created
	assert {:ok, %User{nickname: "nick"}} = User.register(cng)

	# No emails are sent
	ObanHelpers.perform_all()
	refute_email_sent()
	end

	test "it works when the registering user does not provide an email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], true)

	cng = User.register_changeset(%User{}, @full_user_data \|> Map.put(:email, ""))

	# The user is still created
	assert {:ok, %User{nickname: "nick"}} = User.register(cng)

	# No emails are sent
	ObanHelpers.perform_all()
	refute_email_sent()
	end

	test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
	clear_config([:instance, :account_activation_required], true)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
	clear_config([:instance, :account_activation_required], false)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key in [:bio, :email], do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	clear_config([User, :restricted_nicknames], ["about"])
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_binary(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it is case-insensitive when restricting nicknames" do
	clear_config([User, :restricted_nicknames], ["about"])
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_binary(restricted_name)

	restricted_upcase_name = String.upcase(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_upcase_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it blocks blacklisted email domains" do
	clear_config([User, :email_blacklist], ["trolling.world"])

	# Block with match
	params = Map.put(@full_user_data, :email, "troll@trolling.world")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Block with case-insensitive match
	params = Map.put(@full_user_data, :email, "troll@TrOlLing.wOrld")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Block with subdomain match
	params = Map.put(@full_user_data, :email, "troll@gnomes.trolling.world")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Pass with different domains that are similar
	params = Map.put(@full_user_data, :email, "troll@gnomestrolling.world")
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid?

	params = Map.put(@full_user_data, :email, "troll@trolling.world.us")
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid?
	end

	test "it sets the password_hash, ap_id, private key and followers collection address" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert is_binary(changeset.changes[:keys])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it sets the 'accepts_chat_messages' set to true" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.accepts_chat_messages
	end

	test "it creates a confirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.is_confirmed
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}
	setup do: clear_config([:instance, :account_activation_required], true)

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.is_confirmed
	assert user.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.is_confirmed
	refute user.confirmation_token
	end
	end

	describe "user registration, with :account_approval_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com",
	registration_reason: "I'm a cool guy :)"
	}
	setup do: clear_config([:instance, :account_approval_required], true)

	test "it creates unapproved user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.is_approved
	assert user.registration_reason == "I'm a cool guy :)"
	end

	test "it restricts length of registration reason" do
	reason_limit = Pleroma.Config.get([:instance, :registration_reason_length])

	assert is_integer(reason_limit)

	params =
	@full_user_data
	\|> Map.put(
	:registration_reason,
	"Quia et nesciunt dolores numquam ipsam nisi sapiente soluta. Ullam repudiandae nisi quam porro officiis officiis ad. Consequatur animi velit ex quia. Odit voluptatem perferendis quia ut nisi. Dignissimos sit soluta atque aliquid dolorem ut dolorum ut. Labore voluptates iste iusto amet voluptatum earum. Ad fugit illum nam eos ut nemo. Pariatur ea fuga non aspernatur. Dignissimos debitis officia corporis est nisi ab et. Atque itaque alias eius voluptas minus. Accusamus numquam tempore occaecati in."
	)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end
	end

	describe "user registration, with :birthday_required and :birthday_min_age" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do
	clear_config([:instance, :birthday_required], true)
	clear_config([:instance, :birthday_min_age], 18 * 365)
	end

	test "it passes when correct birth date is provided" do
	today = Date.utc_today()
	birthday = Date.add(today, -19 * 365)

	params =
	@full_user_data
	\|> Map.put(:birthday, birthday)

	changeset = User.register_changeset(%User{}, params)

	assert changeset.valid?
	end

	test "it fails when birth date is not provided" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	refute changeset.valid?
	end

	test "it fails when provided invalid birth date" do
	today = Date.utc_today()
	birthday = Date.add(today, -17 * 365)

	params =
	@full_user_data
	\|> Map.put(:birthday, birthday)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id
	)

	{:ok, fetched_user} = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end

	test "gets an existing user by nickname starting with http" do
	user = insert(:user, nickname: "httpssome")
	{:ok, fetched_user} = User.get_or_fetch("httpssome")

	assert user == fetched_user
	end
	end

	describe "get_or_fetch/1 remote users with tld, while BE is running on a subdomain" do
	setup do: clear_config([Pleroma.Web.WebFinger, :update_nickname_on_user_fetch], true)

	- test "for mastodon" do
	- ap_id = "a@mastodon.example"
	- {:ok, fetched_user} = User.get_or_fetch(ap_id)
	+ test "fetches a mastodon split-domain nickname" do
	+ nickname = "a@mastodon.example"
	+ {:ok, fetched_user} = User.get_or_fetch(nickname)

	assert fetched_user.ap_id == "https://sub.mastodon.example/users/a"
	assert fetched_user.nickname == "a@mastodon.example"
	end

	- test "for pleroma" do
	- ap_id = "a@pleroma.example"
	- {:ok, fetched_user} = User.get_or_fetch(ap_id)
	+ test "fetches a pleroma split-domain nickname" do
	+ nickname = "a@pleroma.example"
	+ {:ok, fetched_user} = User.get_or_fetch(nickname)

	assert fetched_user.ap_id == "https://sub.pleroma.example/users/a"
	assert fetched_user.nickname == "a@pleroma.example"
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	{:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	{:ok, fetched_user} =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	{:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "returns nil if no user could be fetched" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistent@social.heldscal.la")
	assert fetched_user == "not found nonexistent@social.heldscal.la"
	end

	test "returns nil for nonexistent local user" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistent")
	assert fetched_user == "not found nonexistent"
	end

	+ test "does not rename an existing remote actor from rogue WebFinger data" do
	+ clear_config([Pleroma.Web.WebFinger, :update_nickname_on_user_fetch], true)
	+
	+ actor_id = "https://legit-actor.example/users/alice"
	+
	+ Tesla.Mock.mock(fn
	+ %{url: "https://evil-webfinger.example/.well-known/host-meta"} ->
	+ {:ok, %Tesla.Env{status: 404}}
	+
	+ %{
	+ url:
	+ "https://evil-webfinger.example/.well-known/webfinger?resource=acct:claimed@evil-webfinger.example"
	+ } ->
	+ Tesla.Mock.json(%{
	+ "subject" => "acct:claimed@evil-webfinger.example",
	+ "links" => [
	+ %{
	+ "rel" => "self",
	+ "type" => "application/activity+json",
	+ "href" => actor_id
	+ }
	+ ]
	+ })
	+
	+ %{url: ^actor_id} ->
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body:
	+ Jason.encode!(%{
	+ "id" => actor_id,
	+ "type" => "Person",
	+ "preferredUsername" => "alice",
	+ "name" => "Alice",
	+ "summary" => "",
	+ "inbox" => "https://legit-actor.example/users/alice/inbox",
	+ "outbox" => "https://legit-actor.example/users/alice/outbox",
	+ "followers" => "https://legit-actor.example/users/alice/followers",
	+ "following" => "https://legit-actor.example/users/alice/following"
	+ })
	+ }}
	+
	+ %{url: "https://legit-actor.example/.well-known/host-meta"} ->
	+ {:ok, %Tesla.Env{status: 404}}
	+
	+ %{
	+ url:
	+ "https://legit-actor.example/.well-known/webfinger?resource=acct:alice@legit-actor.example"
	+ } ->
	+ Tesla.Mock.json(%{
	+ "subject" => "acct:alice@legit-actor.example",
	+ "links" => [
	+ %{
	+ "rel" => "self",
	+ "type" => "application/activity+json",
	+ "href" => actor_id
	+ }
	+ ]
	+ })
	+ end)
	+
	+ assert {:error, {:webfinger_actor_mismatch, "claimed@evil-webfinger.example", ^actor_id}} =
	+ ActivityPub.make_user_from_nickname("claimed@evil-webfinger.example")
	+
	+ refute User.get_by_ap_id(actor_id)
	+ refute User.get_by_nickname("claimed@evil-webfinger.example")
	+
	+ orig_user =
	+ insert(:user,
	+ local: false,
	+ nickname: "alice@legit-actor.example",
	+ ap_id: actor_id
	+ )
	+
	+ assert {:error, {:webfinger_actor_mismatch, "claimed@evil-webfinger.example", ^actor_id}} =
	+ ActivityPub.make_user_from_nickname("claimed@evil-webfinger.example")
	+
	+ assert {:error, _} = User.get_or_fetch_by_nickname("claimed@evil-webfinger.example")
	+ assert User.get_by_id(orig_user.id).nickname == "alice@legit-actor.example"
	+ refute User.get_by_nickname("claimed@evil-webfinger.example")
	+ end
	+
	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	# Oban job was generated to refresh the stale user
	assert_enqueued(worker: "Pleroma.Workers.UserRefreshWorker", args: %{"ap_id" => user.ap_id})

	# Run job to refresh the user; just capture its output instead of fetching it again
	assert {:ok, updated_user} =
	perform_job(Pleroma.Workers.UserRefreshWorker, %{"ap_id" => user.ap_id})

	assert updated_user.inbox

	refute updated_user.last_refreshed_at == orig_user.last_refreshed_at
	end

	test "if nicknames clash, the old user gets a prefix with the old id to the nickname" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	assert user.inbox

	refute user.id == orig_user.id

	orig_user = User.get_by_id(orig_user.id)

	assert orig_user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "it returns the old user if stale, but unfetchable" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/raymoo",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/raymoo")

	assert user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	avatar: %{some: "avatar"}
	}
	setup do: clear_config([:instance, :user_bio_length])
	setup do: clear_config([:instance, :user_name_length])

	test "it confirms validity" do
	cs = User.remote_user_changeset(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_address" do
	cs = User.remote_user_changeset(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_changeset(%{@valid_remote \| nickname: "bla"})
	assert Ecto.Changeset.get_field(cs, :local) == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_changeset(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it is invalid given a local user" do
	user = insert(:user)
	cs = User.remote_user_changeset(user, %{name: "tom from myspace"})

	refute cs.valid?
	end

	test "it truncates fields" do
	clear_config([:instance, :max_remote_account_fields], 2)

	fields = [
	%{"name" => "One", "value" => "Uno"},
	%{"name" => "Two", "value" => "Dos"},
	%{"name" => "Three", "value" => "Tres"}
	]

	cs = User.remote_user_changeset(@valid_remote \|> Map.put(:fields, fields))

	assert [%{"name" => "One", "value" => "Uno"}, %{"name" => "Two", "value" => "Dos"}] ==
	Ecto.Changeset.get_field(cs, :fields)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one, user} = User.follow(follower_one, user)
	{:ok, follower_two, user} = User.follow(follower_two, user)

	res = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user, followed_one} = User.follow(user, followed_one)
	{:ok, user, followed_two} = User.follow(user, followed_two)

	res = User.get_friends(user)

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the note_count property" do
	note = insert(:note)

	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.note_count == 1
	end

	test "it increases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 2
	end

	test "it decreases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0
	end

	test "it sets the follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.follower_count == 1
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, _user_relationships} = User.mute(user, muted_user)

	assert User.mutes?(user, muted_user)
	assert User.muted_notifications?(user, muted_user)
	end

	test "expiring" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user, %{duration: 60})
	assert User.mutes?(user, muted_user)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_user", "muter_id" => user.id, "mutee_id" => muted_user.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users by id" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user.id, muted_user.id)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it mutes user without notifications" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, _user_relationships} = User.mute(user, muted_user, %{notifications: false})

	assert User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, _user_relationship} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked_user)
	{:ok, _user_block} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker, blocked} = User.follow(blocker, blocked)
	{:ok, blocked, blocker} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker, blocked} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked, blocker} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker subscription relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _subscription} = User.subscribe(blocked, blocker)

	assert User.subscribed_to?(blocked, blocker)
	refute User.subscribed_to?(blocker, blocked)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	refute User.subscribed_to?(blocker, blocked)
	refute User.subscribed_to?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end if wildcard added" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "blocks domain with wildcard for subdomain" do
	user = insert(:user)

	user_from_subdomain =
	insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})

	user_with_two_subdomains =
	insert(:user, %{
	ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
	})

	user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	assert User.blocks?(user, user_from_subdomain)
	assert User.blocks?(user, user_with_two_subdomains)
	assert User.blocks?(user, user_domain)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "follows take precedence over domain blocks" do
	user = insert(:user)
	good_eggo = insert(:user, %{ap_id: "https://meanies.social/user/cuteposter"})

	{:ok, user} = User.block_domain(user, "meanies.social")
	{:ok, user, good_eggo} = User.follow(user, good_eggo)

	refute User.blocks?(user, good_eggo)
	end
	end

	describe "get_recipients_from_activity" do
	test "works for announces" do
	actor = insert(:user)
	user = insert(:user, local: true)

	{:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
	{:ok, announce} = CommonAPI.repeat(activity.id, user)

	recipients = User.get_recipients_from_activity(announce)

	assert user in recipients
	end

	test "get recipients" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user, actor} = User.follow(user, actor)
	{:ok, _user_two, _actor} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test "has following" do
	actor = insert(:user)
	user = insert(:user)
	user_two = insert(:user)
	addressed = insert(:user, local: true)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: "hey @#{addressed.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, _actor, _user} = User.follow(actor, user)
	{:ok, _actor, _user_two} = User.follow(actor, user_two)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert addressed in recipients
	end
	end

	describe ".set_activation" do
	test "can de-activate then re-activate a user" do
	user = insert(:user)
	assert user.is_active
	{:ok, user} = User.set_activation(user, false)
	refute user.is_active
	{:ok, user} = User.set_activation(user, true)
	assert user.is_active
	end

	test "hide a user from followers" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user, user2} = User.follow(user, user2)
	{:ok, _user} = User.set_activation(user, false)

	user2 = User.get_cached_by_id(user2.id)

	assert user2.follower_count == 0
	assert [] = User.get_followers(user2)
	end

	test "hide a user from friends" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2, user} = User.follow(user2, user)
	assert user2.following_count == 1
	assert User.following_count(user2) == 1

	{:ok, _user} = User.set_activation(user, false)

	user2 = User.get_cached_by_id(user2.id)

	assert refresh_record(user2).following_count == 0
	assert user2.following_count == 0
	assert User.following_count(user2) == 0
	assert [] = User.get_friends(user2)
	end

	test "hide a user's statuses from timelines and notifications" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2, user} = User.follow(user2, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{user2.nickname}"})

	activity = Repo.preload(activity, :bookmark)

	[notification] = Pleroma.Notification.for_user(user2)
	assert notification.activity.id == activity.id

	assert [activity] == ActivityPub.fetch_public_activities(%{}) \|> Repo.preload(:bookmark)

	assert [%{activity \| thread_muted?: CommonAPI.thread_muted?(activity, user2)}] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	user: user2
	})

	{:ok, _user} = User.set_activation(user, false)

	assert [] == ActivityPub.fetch_public_activities(%{})
	assert [] == Pleroma.Notification.for_user(user2)

	assert [] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	user: user2
	})
	end
	end

	describe "approve" do
	test "approves a user" do
	user = insert(:user, is_approved: false)
	refute user.is_approved
	{:ok, user} = User.approve(user)
	assert user.is_approved
	end

	test "approves a list of users" do
	unapproved_users = [
	insert(:user, is_approved: false),
	insert(:user, is_approved: false),
	insert(:user, is_approved: false)
	]

	{:ok, users} = User.approve(unapproved_users)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_approved
	end)
	end

	test "it sends welcome email if it is set" do
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], "tester@test.me")

	user = insert(:user, is_approved: false)
	welcome_user = insert(:user, email: "tester@test.me")
	instance_name = Pleroma.Config.get([:instance, :name])

	User.approve(user)

	ObanHelpers.perform_all()

	assert_email_sent(
	from: {instance_name, welcome_user.email},
	to: {user.name, user.email},
	html_body: "Welcome to #{instance_name}"
	)
	end

	test "approving an approved user does not trigger post-register actions" do
	clear_config([:welcome, :email, :enabled], true)

	user = insert(:user, is_approved: true)
	User.approve(user)

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

	describe "confirm" do
	test "confirms a user" do
	user = insert(:user, is_confirmed: false)
	refute user.is_confirmed
	{:ok, user} = User.confirm(user)
	assert user.is_confirmed
	end

	test "confirms a list of users" do
	unconfirmed_users = [
	insert(:user, is_confirmed: false),
	insert(:user, is_confirmed: false),
	insert(:user, is_confirmed: false)
	]

	{:ok, users} = User.confirm(unconfirmed_users)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_confirmed
	end)
	end

	test "sends approval emails when `is_approved: false`" do
	admin = insert(:user, is_admin: true)
	user = insert(:user, is_confirmed: false, is_approved: false)
	User.confirm(user)

	ObanHelpers.perform_all()

	user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
	admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	# User approval email
	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: user_email.html_body
	)

	# Admin email
	assert_email_sent(
	from: {instance_name, notify_email},
	to: {admin.name, admin.email},
	html_body: admin_email.html_body
	)
	end

	test "confirming a confirmed user does not trigger post-register actions" do
	user = insert(:user, is_confirmed: true, is_approved: false)
	User.confirm(user)

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

	describe "delete" do
	setup do
	{:ok, user} = insert(:user) \|> User.set_cache()

	[user: user]
	end

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

	test ".delete_user_activities deletes all create activities", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "2hu"})

	User.delete_user_activities(user)

	# TODO: Test removal favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test "it deactivates a user, all follow relationships and all activities", %{user: user} do
	follower = insert(:user)
	{:ok, follower, user} = User.follow(follower, user)

	locked_user = insert(:user, name: "locked", is_locked: true)
	{:ok, _, _} = User.follow(user, locked_user, :follow_pending)

	object = insert(:note, user: user)
	activity = insert(:note_activity, user: user, note: object)

	object_two = insert(:note, user: follower)
	activity_two = insert(:note_activity, user: follower, note: object_two)

	{:ok, like} = CommonAPI.favorite(activity_two.id, user)
	{:ok, like_two} = CommonAPI.favorite(activity.id, follower)
	{:ok, repeat} = CommonAPI.repeat(activity_two.id, user)

	{:ok, job} = User.delete(user)
	{:ok, _user} = ObanHelpers.perform(job)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	assert %{is_active: false} = User.get_by_id(user.id)

	assert [] == User.get_follow_requests(locked_user)

	user_activities =
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.all()
	\|> Enum.map(fn act -> act.data["type"] end)

	assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)

	refute Activity.get_by_id(activity.id)
	refute Activity.get_by_id(like.id)
	refute Activity.get_by_id(like_two.id)
	refute Activity.get_by_id(repeat.id)
	end
	end

	test "delete/1 when confirmation is pending deletes the user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: false)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	refute User.get_cached_by_id(user.id)
	refute User.get_by_id(user.id)
	end

	test "delete/1 when approval is pending deletes the user" do
	user = insert(:user, is_approved: false)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	refute User.get_cached_by_id(user.id)
	refute User.get_by_id(user.id)
	end

	test "delete/1 purges a user when they wouldn't be fully deleted" do
	user =
	insert(:user, %{
	bio: "eyy lmao",
	name: "qqqqqqq",
	password_hash: "pdfk2$1b3n159001",
	keys: "RSA begin buplic key",
	public_key: "--PRIVATE KEYE--",
	avatar: %{"a" => "b"},
	tags: ["qqqqq"],
	banner: %{"a" => "b"},
	background: %{"a" => "b"},
	note_count: 9,
	follower_count: 9,
	following_count: 9001,
	is_locked: true,
	is_confirmed: true,
	password_reset_pending: true,
	is_approved: true,
	registration_reason: "ahhhhh",
	confirmation_token: "qqqq",
	domain_blocks: ["lain.com"],
	is_active: false,
	is_moderator: true,
	is_admin: true,
	mascot: %{"a" => "b"},
	emoji: %{"a" => "b"},
	pleroma_settings_store: %{"q" => "x"},
	fields: [%{"gg" => "qq"}],
	raw_fields: [%{"gg" => "qq"}],
	is_discoverable: true,
	also_known_as: ["https://lol.olo/users/loll"]
	})

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)
	user = User.get_by_id(user.id)

	assert %User{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	keys: "RSA begin buplic key",
	public_key: "--PRIVATE KEYE--",
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	is_locked: false,
	is_confirmed: true,
	password_reset_pending: false,
	is_approved: true,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	is_moderator: false,
	is_admin: false,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	} = user
	end

	test "delete/1 purges a remote user" do
	user =
	insert(:user, %{
	name: "qqqqqqq",
	avatar: %{"a" => "b"},
	banner: %{"a" => "b"},
	local: false
	})

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)
	user = User.get_by_id(user.id)

	assert user.name == nil
	assert user.avatar == %{}
	assert user.banner == %{}
	end

	describe "set_suggestion" do
	test "suggests a user" do
	user = insert(:user, is_suggested: false)
	refute user.is_suggested
	{:ok, user} = User.set_suggestion(user, true)
	assert user.is_suggested
	end

	test "suggests a list of users" do
	unsuggested_users = [
	insert(:user, is_suggested: false),
	insert(:user, is_suggested: false),
	insert(:user, is_suggested: false)
	]

	{:ok, users} = User.set_suggestion(unsuggested_users, true)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_suggested
	end)
	end

	test "unsuggests a user" do
	user = insert(:user, is_suggested: true)
	assert user.is_suggested
	{:ok, user} = User.set_suggestion(user, false)
	refute user.is_suggested
	end
	end

	test "get_or_fetch_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} =
	User.get_or_fetch_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "get_public_key_for_ap_id returns correctly for user that's not in the db" do
	assert :error = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, no_rich_text: true)

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)

	User.set_cache(user)
	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "account_status/1" do
	setup do: clear_config([:instance, :account_activation_required])

	test "return confirmation_pending for unconfirm user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: false)
	assert User.account_status(user) == :confirmation_pending
	end

	test "return active for confirmed user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: true)
	assert User.account_status(user) == :active
	end

	test "return active for remote user" do
	user = insert(:user, local: false)
	assert User.account_status(user) == :active
	end

	test "returns :password_reset_pending for user with reset password" do
	user = insert(:user, password_reset_pending: true)
	assert User.account_status(user) == :password_reset_pending
	end

	test "returns :deactivated for deactivated user" do
	user = insert(:user, local: true, is_confirmed: true, is_active: false)
	assert User.account_status(user) == :deactivated
	end

	test "returns :approval_pending for unapproved user" do
	user = insert(:user, local: true, is_approved: false)
	assert User.account_status(user) == :approval_pending

	user = insert(:user, local: true, is_confirmed: false, is_approved: false)
	assert User.account_status(user) == :approval_pending
	end
	end

	describe "privileged?/1" do
	setup do
	clear_config([:instance, :admin_privileges], [:cofe, :suya])
	clear_config([:instance, :moderator_privileges], [:cofe, :suya])
	end

	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.privileged?(user, :cofe)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, is_admin: true)

	refute User.privileged?(user, :cofe)
	refute User.privileged?(remote_admin_user, :cofe)
	end

	test "returns true for local moderators if, and only if, they are privileged" do
	user = insert(:user, local: true, is_moderator: true)

	assert User.privileged?(user, :cofe)

	clear_config([:instance, :moderator_privileges], [])

	refute User.privileged?(user, :cofe)
	end

	test "returns true for local admins if, and only if, they are privileged" do
	user = insert(:user, local: true, is_admin: true)

	assert User.privileged?(user, :cofe)

	clear_config([:instance, :admin_privileges], [])

	refute User.privileged?(user, :cofe)
	end
	end

	describe "privileges/1" do
	setup do
	clear_config([:instance, :moderator_privileges], [:cofe, :only_moderator])
	clear_config([:instance, :admin_privileges], [:cofe, :only_admin])
	end

	test "returns empty list for users without roles" do
	user = insert(:user, local: true)

	assert [] == User.privileges(user)
	end

	test "returns list of privileges for moderators" do
	moderator = insert(:user, is_moderator: true, local: true)

	assert [:cofe, :only_moderator] == User.privileges(moderator) \|> Enum.sort()
	end

	test "returns list of privileges for admins" do
	admin = insert(:user, is_admin: true, local: true)

	assert [:cofe, :only_admin] == User.privileges(admin) \|> Enum.sort()
	end

	test "returns list of unique privileges for users who are both moderator and admin" do
	moderator_admin = insert(:user, is_moderator: true, is_admin: true, local: true)

	assert [:cofe, :only_admin, :only_moderator] ==
	User.privileges(moderator_admin) \|> Enum.sort()
	end

	test "returns empty list for remote users" do
	remote_moderator_admin = insert(:user, is_moderator: true, is_admin: true, local: false)

	assert [] == User.privileges(remote_moderator_admin)
	end
	end

	describe "invisible?/1" do
	test "returns true for an invisible user" do
	user = insert(:user, local: true, invisible: true)

	assert User.invisible?(user)
	end

	test "returns false for a non-invisible user" do
	user = insert(:user, local: true)

	refute User.invisible?(user)
	end
	end

	describe "visible_for/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for(user, user) == :visible
	end

	test "returns false when the account is unconfirmed and confirmation is required" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true)

	refute User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: false, is_confirmed: false)
	other_user = insert(:user, local: true)

	assert User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and being viewed by a privileged account (privilege :users_manage_activation_state, confirmation required)" do
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :admin_privileges], [:users_manage_activation_state])

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true, is_admin: true)

	assert User.visible_for(user, other_user) == :visible

	clear_config([:instance, :admin_privileges], [])

	refute User.visible_for(user, other_user) == :visible
	end
	end

	describe "all_users_with_privilege/1" do
	setup do
	%{
	user: insert(:user, local: true, is_admin: false, is_moderator: false),
	moderator_user: insert(:user, local: true, is_admin: false, is_moderator: true),
	admin_user: insert(:user, local: true, is_admin: true, is_moderator: false),
	admin_moderator_user: insert(:user, local: true, is_admin: true, is_moderator: true),
	remote_user: insert(:user, local: false, is_admin: true, is_moderator: true),
	non_active_user:
	insert(:user, local: true, is_admin: true, is_moderator: true, is_active: false)
	}
	end

	test "doesn't return any users when there are no privileged roles" do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [])

	assert [] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	end

	test "returns moderator users if they are privileged", %{
	moderator_user: moderator_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [:cofe])

	assert [_, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert moderator_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end

	test "returns admin users if they are privileged", %{
	admin_user: admin_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [:cofe])
	clear_config([:instance, :moderator_privileges], [])

	assert [_, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert admin_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end

	test "returns admin and moderator users if they are both privileged", %{
	moderator_user: moderator_user,
	admin_user: admin_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [:cofe])
	clear_config([:instance, :moderator_privileges], [:cofe])

	assert [_, _, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert admin_user in User.all_users_with_privilege(:cofe)
	assert moderator_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	~s(A.k.a. <span class="h-card"><a class="u-url mention" data-user="#{remote_user.id}" href="#{remote_user.ap_id}" rel="ugc">@<span>nick@domain.com</span></a></span>)

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	bio = "http://example.com/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/link"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower, user} = User.follow(follower, user)
	{:ok, _follower2, _user} = User.follow(follower2, user)
	{:ok, _follower3, _user} = User.follow(follower3, user)

	{:ok, _user_relationship} = User.block(user, follower)
	user = refresh_record(user)

	assert user.follower_count == 2
	end

	describe "list_inactive_users_query/1" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Users are inactive by default" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(users, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users who has no recent activity" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	{inactive, active} = Enum.split(users, trunc(total / 2))

	Enum.map(active, fn user ->
	to = Enum.random(users -- [user])

	{:ok, _} =
	CommonAPI.post(user, %{
	status: "hey @#{to.nickname}"
	})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users with no read notifications" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	[sender \| recipients] = users
	{inactive, active} = Enum.split(recipients, trunc(total / 2))

	Enum.each(recipients, fn to ->
	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey @#{to.nickname}"
	})

	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey again @#{to.nickname}"
	})
	end)

	Enum.each(active, fn user ->
	[n1, _n2] = Pleroma.Notification.for_user(user)
	{:ok, _} = Pleroma.Notification.read_one(user, n1.id)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end
	end

	describe "get_ap_ids_by_nicknames" do
	test "it returns a list of AP ids for a given set of nicknames" do
	user = insert(:user)
	user_two = insert(:user)

	ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
	assert length(ap_ids) == 2
	assert user.ap_id in ap_ids
	assert user_two.ap_id in ap_ids
	end

	test "it returns a list of AP ids in the same order" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	ap_ids =
	User.get_ap_ids_by_nicknames([user.nickname, user_three.nickname, user_two.nickname])

	assert [user.ap_id, user_three.ap_id, user_two.ap_id] == ap_ids
	end
	end

	describe "sync followers count" do
	setup do
	user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
	user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
	insert(:user, local: true)
	insert(:user, local: false, is_active: false)
	{:ok, user1: user1, user2: user2}
	end

	test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
	[fdb_user1] = User.external_users(limit: 1)

	assert fdb_user1.ap_id
	assert fdb_user1.ap_id == user1.ap_id
	assert fdb_user1.id == user1.id

	[fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)

	assert fdb_user2.ap_id
	assert fdb_user2.ap_id == user2.ap_id
	assert fdb_user2.id == user2.id

	assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
	end
	end

	describe "internal?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.internal?(user)
	end

	test "user with no nickname returns true" do
	user = insert(:user, %{nickname: nil})
	assert User.internal?(user)
	end

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.internal?(user)
	end
	end

	describe "update_and_set_cache/1" do
	test "returns error when user is stale instead Ecto.StaleEntryError" do
	user = insert(:user)

	changeset = Ecto.Changeset.change(user, bio: "test")

	Repo.delete(user)

	assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
	User.update_and_set_cache(changeset)
	end

	test "performs update cache if user updated" do
	user = insert(:user)
	assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	changeset = Ecto.Changeset.change(user, bio: "test-bio")

	assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
	assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
	end
	end

	describe "following/followers synchronization" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "updates the counters normally on following/getting a follow when disabled" do
	clear_config([:instance, :external_user_synchronization], false)
	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	{:ok, user, other_user} = Pleroma.User.follow(user, other_user)

	assert user.following_count == 1
	assert other_user.follower_count == 1
	end

	test "synchronizes the counters with the remote instance for the followed when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, _user, other_user} = User.follow(user, other_user)

	assert other_user.follower_count == 437
	end

	test "synchronizes the counters with the remote instance for the follower when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, other_user, _user} = User.follow(other_user, user)

	assert other_user.following_count == 152
	end
	end

	describe "change_email/2" do
	setup do
	[user: insert(:user)]
	end

	test "blank email returns error if we require an email on registration", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], true)

	on_exit(fn ->
	Pleroma.Config.put(
	[:instance, :account_activation_required],
	orig_account_activation_required
	)
	end)

	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
	end

	test "blank email should be fine if we do not require an email on registration", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], false)

	on_exit(fn ->
	Pleroma.Config.put(
	[:instance, :account_activation_required],
	orig_account_activation_required
	)
	end)

	assert {:ok, %User{email: nil}} = User.change_email(user, "")
	assert {:ok, %User{email: nil}} = User.change_email(user, nil)
	end

	test "non unique email returns error", %{user: user} do
	%{email: email} = insert(:user)

	assert {:error, %{errors: [email: {"has already been taken", _}]}} =
	User.change_email(user, email)
	end

	test "invalid email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"has invalid format", _}]}} =
	User.change_email(user, "cofe")
	end

	test "changes email", %{user: user} do
	assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
	end

	test "adds email", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], false)

	on_exit(fn ->
	Pleroma.Config.put(
	[:instance, :account_activation_required],
	orig_account_activation_required
	)
	end)

	assert {:ok, _} = User.change_email(user, "")
	Pleroma.Config.put([:instance, :account_activation_required], true)

	assert {:ok, %User{email: "cofe2@cofe.party"}} = User.change_email(user, "cofe2@cofe.party")
	end
	end

	describe "get_cached_by_nickname_or_id" do
	setup do
	local_user = insert(:user)
	remote_user = insert(:user, nickname: "nickname@example.com", local: false)

	[local_user: local_user, remote_user: remote_user]
	end

	setup do: clear_config([:instance, :limit_to_local_content])

	test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
	remote_user: remote_user
	} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
	end

	test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user, local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
	end

	test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], true)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
	%{local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
	end
	end

	describe "update_email_notifications/2" do
	setup do
	user = insert(:user, email_notifications: %{"digest" => true})

	{:ok, user: user}
	end

	test "Notifications are updated", %{user: user} do
	true = user.email_notifications["digest"]
	assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
	assert result.email_notifications["digest"] == false
	end
	end

	describe "local_nickname/1" do
	test "returns nickname without host" do
	assert User.local_nickname("@mentioned") == "mentioned"
	assert User.local_nickname("a_local_nickname") == "a_local_nickname"
	assert User.local_nickname("nickname@host.com") == "nickname"
	end
	end

	describe "full_nickname/1" do
	test "returns fully qualified nickname for local users" do
	local_user = insert(:user, nickname: "local_user")

	assert User.full_nickname(local_user) == "local_user@localhost"
	end

	test "returns fully qualified nickname for local users when using different domain for webfinger" do
	clear_config([Pleroma.Web.WebFinger, :domain], "plemora.dev")

	local_user = insert(:user, nickname: "local_user")

	assert User.full_nickname(local_user) == "local_user@plemora.dev"
	end

	test "returns fully qualified nickname for remote users" do
	remote_user = insert(:user, nickname: "remote@host.com", local: false)

	assert User.full_nickname(remote_user) == "remote@host.com"
	end

	test "strips leading @ from mentions" do
	assert User.full_nickname("@mentioned") == "mentioned"
	assert User.full_nickname("@nickname@host.com") == "nickname@host.com"
	end

	test "does not modify nicknames" do
	assert User.full_nickname("nickname") == "nickname"
	assert User.full_nickname("nickname@host.com") == "nickname@host.com"
	end
	end

	test "avatar fallback" do
	user = insert(:user)
	assert User.avatar_url(user) =~ "/images/avi.png"

	clear_config([:assets, :default_user_avatar], "avatar.png")

	user = User.get_cached_by_nickname_or_id(user.nickname)
	assert User.avatar_url(user) =~ "avatar.png"

	assert User.avatar_url(user, no_default: true) == nil
	end

	test "get_host/1" do
	user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
	assert User.get_host(user) == "lain.com"
	end

	test "update_last_active_at/1" do
	user = insert(:user)
	assert is_nil(user.last_active_at)

	test_started_at = NaiveDateTime.utc_now() \|> NaiveDateTime.truncate(:second)

	assert {:ok, user} = User.update_last_active_at(user)

	assert NaiveDateTime.compare(user.last_active_at, test_started_at) in [:gt, :eq]

	assert NaiveDateTime.compare(
	user.last_active_at,
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	) in [:lt, :eq]

	last_active_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(-:timer.hours(24), :millisecond)
	\|> NaiveDateTime.truncate(:second)

	assert {:ok, user} =
	user
	\|> cast(%{last_active_at: last_active_at}, [:last_active_at])
	\|> User.update_and_set_cache()

	assert NaiveDateTime.compare(user.last_active_at, last_active_at) == :eq

	assert {:ok, user} = User.update_last_active_at(user)
	assert NaiveDateTime.compare(user.last_active_at, test_started_at) in [:gt, :eq]

	assert NaiveDateTime.compare(
	user.last_active_at,
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	) in [:lt, :eq]
	end

	test "active_user_count/1" do
	insert(:user)
	insert(:user, %{local: false})
	insert(:user, %{last_active_at: NaiveDateTime.utc_now()})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), days: -15)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -6)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), months: -7)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), years: -2)})

	assert User.active_user_count() == 2
	assert User.active_user_count(180) == 3
	assert User.active_user_count(365) == 4
	assert User.active_user_count(1000) == 5
	end

	describe "pins" do
	setup do
	user = insert(:user)

	[user: user, object_id: object_id_from_created_activity(user)]
	end

	test "unique pins", %{user: user, object_id: object_id} do
	assert {:ok, %{pinned_objects: %{^object_id => pinned_at1} = pins} = updated_user} =
	User.add_pinned_object_id(user, object_id)

	assert Enum.count(pins) == 1

	assert {:ok, %{pinned_objects: %{^object_id => pinned_at2} = pins}} =
	User.add_pinned_object_id(updated_user, object_id)

	assert pinned_at1 == pinned_at2

	assert Enum.count(pins) == 1
	end

	test "respects max_pinned_statuses limit", %{user: user, object_id: object_id} do
	clear_config([:instance, :max_pinned_statuses], 1)
	{:ok, updated} = User.add_pinned_object_id(user, object_id)

	object_id2 = object_id_from_created_activity(user)

	{:error, %{errors: errors}} = User.add_pinned_object_id(updated, object_id2)
	assert Keyword.has_key?(errors, :pinned_objects)
	end

	test "remove_pinned_object_id/2", %{user: user, object_id: object_id} do
	assert {:ok, updated} = User.add_pinned_object_id(user, object_id)

	{:ok, after_remove} = User.remove_pinned_object_id(updated, object_id)
	assert after_remove.pinned_objects == %{}
	end
	end

	defp object_id_from_created_activity(user) do
	%{id: id} = insert(:note_activity, user: user)
	%{object: %{data: %{"id" => object_id}}} = Activity.get_by_id_with_object(id)
	object_id
	end

	describe "add_alias/2" do
	test "should add alias for another user" do
	user = insert(:user)
	user2 = insert(:user)

	assert {:ok, user_updated} = user \|> User.add_alias(user2)

	assert user_updated.also_known_as \|> length() == 1
	assert user2.ap_id in user_updated.also_known_as
	end

	test "should add multiple aliases" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	assert {:ok, user} = user \|> User.add_alias(user2)
	assert {:ok, user_updated} = user \|> User.add_alias(user3)

	assert user_updated.also_known_as \|> length() == 2
	assert user2.ap_id in user_updated.also_known_as
	assert user3.ap_id in user_updated.also_known_as
	end

	test "should not add duplicate aliases" do
	user = insert(:user)
	user2 = insert(:user)

	assert {:ok, user} = user \|> User.add_alias(user2)

	assert {:ok, user_updated} = user \|> User.add_alias(user2)

	assert user_updated.also_known_as \|> length() == 1
	assert user2.ap_id in user_updated.also_known_as
	end

	test "should tolerate non-http(s) aliases" do
	user =
	insert(:user, %{
	also_known_as: ["at://did:plc:xgvzy7ni6ig6ievcbls5jaxe"]
	})

	assert "at://did:plc:xgvzy7ni6ig6ievcbls5jaxe" in user.also_known_as
	end
	end

	describe "alias_users/1" do
	test "should get aliases for a user" do
	user = insert(:user)
	user2 = insert(:user, also_known_as: [user.ap_id])

	aliases = user2 \|> User.alias_users()

	assert aliases \|> length() == 1

	alias_user = aliases \|> Enum.at(0)

	assert alias_user.ap_id == user.ap_id
	end
	end

	describe "delete_alias/2" do
	test "should delete existing alias" do
	user = insert(:user)
	user2 = insert(:user, also_known_as: [user.ap_id])

	assert {:ok, user_updated} = user2 \|> User.delete_alias(user)

	assert user_updated.also_known_as == []
	end

	test "should report error on non-existing alias" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user, also_known_as: [user.ap_id])

	assert {:error, :no_such_alias} = user3 \|> User.delete_alias(user2)

	user3_updated = User.get_cached_by_ap_id(user3.ap_id)

	assert user3_updated.also_known_as \|> length() == 1
	assert user.ap_id in user3_updated.also_known_as
	end
	end

	describe "get_familiar_followers/3" do
	test "returns familiar followers for a pair of users" do
	user1 = insert(:user)
	%{id: id2} = user2 = insert(:user)
	user3 = insert(:user)
	_user4 = insert(:user)

	User.follow(user1, user2)
	User.follow(user2, user3)

	assert [%{id: ^id2}] = User.get_familiar_followers(user3, user1)
	end
	end

	describe "account endorsements" do
	test "it pins people" do
	user = insert(:user)
	pinned_user = insert(:user)

	{:ok, _pinned_user, _user} = User.follow(user, pinned_user)

	refute User.endorses?(user, pinned_user)

	{:ok, _user_relationship} = User.endorse(user, pinned_user)

	assert User.endorses?(user, pinned_user)
	end

	test "it unpins users" do
	user = insert(:user)
	pinned_user = insert(:user)

	{:ok, _pinned_user, _user} = User.follow(user, pinned_user)
	{:ok, _user_relationship} = User.endorse(user, pinned_user)
	{:ok, _user_pin} = User.unendorse(user, pinned_user)

	refute User.endorses?(user, pinned_user)
	end

	test "it doesn't pin users you do not follow" do
	user = insert(:user)
	pinned_user = insert(:user)

	assert {:error, _message} = User.endorse(user, pinned_user)

	refute User.endorses?(user, pinned_user)
	end
	end

	test "it checks fields links for a backlink" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	fields = [
	%{"name" => "Link", "value" => "http://example.com/rel_me/null"},
	%{"name" => "Verified link", "value" => "http://example.com/rel_me/link"},
	%{"name" => "Not a link", "value" => "i'm not a link"}
	]

	user
	\|> User.update_and_set_cache(%{raw_fields: fields})

	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	assert [
	%{"verified_at" => nil},
	%{"verified_at" => verified_at},
	%{"verified_at" => nil}
	] = user.fields

	assert is_binary(verified_at)
	end

	test "updating fields does not invalidate previously validated links" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	user
	\|> User.update_and_set_cache(%{
	raw_fields: [%{"name" => "verified link", "value" => "http://example.com/rel_me/link"}]
	})

	ObanHelpers.perform_all()

	%User{fields: [%{"verified_at" => verified_at}]} = user = User.get_cached_by_id(user.id)

	user
	\|> User.update_and_set_cache(%{
	raw_fields: [%{"name" => "Verified link", "value" => "http://example.com/rel_me/link"}]
	})

	user = User.get_cached_by_id(user.id)

	assert [%{"verified_at" => ^verified_at}] = user.fields
	end

	describe "follow_hashtag/2" do
	test "should follow a hashtag" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 1
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end

	test "should not follow a hashtag twice" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 1
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end

	test "can follow multiple hashtags" do
	user = insert(:user)
	hashtag = insert(:hashtag)
	other_hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.follow_hashtag(other_hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 2
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	assert other_hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end
	end

	describe "unfollow_hashtag/2" do
	test "should unfollow a hashtag" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 0
	end

	test "should not error when trying to unfollow a hashtag twice" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 0
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	index d5947186f..3988c3912 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,2690 +1,2919 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	require Pleroma.Constants

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

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

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

	+ defp assign_valid_signature_for_actor(conn, %User{ap_id: actor_id}) do
	+ assign_valid_signature_for_actor(conn, actor_id)
	+ end
	+
	+ defp assign_valid_signature_for_actor(conn, actor) do
	+ actor_id = Utils.get_ap_id(actor)
	+
	+ conn
	+ \|> assign(:valid_signature, true)
	+ \|> put_req_header("signature", "keyId=\"#{actor_id}#main-key\"")
	+ end
	+
	+ defp expect_signature_retry_from(%User{} = signer) do
	+ signer_json = UserView.render("user.json", %{user: signer}) \|> Map.delete("featured")
	+
	+ Tesla.Mock.mock(fn
	+ %{url: url} when url == signer.ap_id ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: Jason.encode!(signer_json),
	+ headers: HttpRequestMock.activitypub_object_headers()
	+ }
	+
	+ env ->
	+ apply(HttpRequestMock, :request, [env])
	+ end)
	+
	+ Mox.expect(Pleroma.StubbedHTTPSignaturesMock, :validate_conn, fn _conn -> true end)
	+ end
	+
	describe "/relay" do
	setup do: clear_config([:instance, :allow_relay])

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

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

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

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

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

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

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

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

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

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

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

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

	user = User.get_cached_by_id(user.id)

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

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

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

	user = User.get_cached_by_id(user.id)

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

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

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

	user = User.get_cached_by_id(user.id)

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

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

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

	assert json_response(conn, 404)
	end

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

	assert response == "Not found"
	end
	end

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

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

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

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

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

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

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

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

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

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

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

	assert json_response(conn, 404)
	end

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

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

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

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

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

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

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

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

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

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

	json_response(response, 404)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

	json_response(response, 200)

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

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

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

	assert json_response(conn, 404)
	end

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

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

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

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

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

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

	assert json_response(conn, 404)
	end

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

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

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

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

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

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

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

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

	Object.delete(note)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	res = json_response(conn, 200)

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

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

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

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

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

	assert json_response(conn, 404)
	end

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

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

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

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

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

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

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

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

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

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

	assert json_response(conn, 404)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	test "it inserts an incoming activity into the database" <>
	"even if we can't fetch the user but have it in our db",
	%{conn: conn} do
	user =
	insert(:user,
	ap_id: "https://mastodon.example.org/users/raymoo",
	local: false,
	last_refreshed_at: nil
	)

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

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

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

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

	+ test "does not create a forged post after failed signature retry", %{conn: conn} do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ object_id = "https://two.com/objects/inbox-forged-note"
	+
	+ data = %{
	+ "type" => "Create",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/inbox-forged-create",
	+ "context" => "https://two.com/contexts/inbox-forged-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => object_id,
	+ "actor" => bob.ap_id,
	+ "attributedTo" => bob.ap_id,
	+ "context" => "https://two.com/contexts/inbox-forged-create",
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ expect_signature_retry_from(alice)
	+
	+ conn =
	+ conn
	+ \|> assign(:valid_signature, false)
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("signature", "keyId=\"https://one.com/users/alice#main-key\"")
	+ \|> post("/inbox", data)
	+
	+ assert "ok" == json_response(conn, 200)
	+
	+ assert [{:cancel, :actor_signature_mismatch}] =
	+ ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))
	+
	+ refute Activity.get_by_ap_id(data["id"])
	+ refute Object.get_by_ap_id(object_id)
	+ end
	+
	+ test "does not create a forged like after failed signature retry", %{conn: conn} do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ note = insert(:note)
	+
	+ data = %{
	+ "type" => "Like",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/inbox-forged-like",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data["id"]
	+ }
	+
	+ expect_signature_retry_from(alice)
	+
	+ conn =
	+ conn
	+ \|> assign(:valid_signature, false)
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("signature", "keyId=\"https://one.com/users/alice#main-key\"")
	+ \|> post("/inbox", data)
	+
	+ assert "ok" == json_response(conn, 200)
	+
	+ assert [{:cancel, :actor_signature_mismatch}] =
	+ ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))
	+
	+ refute Activity.get_by_ap_id(data["id"])
	+ end
	+
	+ test "does not delete an object after failed signature retry", %{conn: conn} do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ note = insert(:note)
	+ object_id = note.data["id"]
	+
	+ data = %{
	+ "type" => "Delete",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/inbox-forged-delete",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => object_id
	+ }
	+
	+ expect_signature_retry_from(alice)
	+
	+ conn =
	+ conn
	+ \|> assign(:valid_signature, false)
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("signature", "keyId=\"https://one.com/users/alice#main-key\"")
	+ \|> post("/inbox", data)
	+
	+ assert "ok" == json_response(conn, 200)
	+
	+ assert [{:cancel, :actor_signature_mismatch}] =
	+ ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))
	+
	+ refute Activity.get_by_ap_id(data["id"])
	+ assert %Object{data: %{"type" => "Note"}} = Object.get_by_ap_id(object_id)
	+ end
	+
	+ test "does not create a forged post signed by a different actor", %{conn: conn} do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ object_id = "https://two.com/objects/inbox-signed-forged-note"
	+
	+ data = %{
	+ "@context" => "https://www.w3.org/ns/activitystreams",
	+ "type" => "Create",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/inbox-signed-forged-create",
	+ "context" => "https://two.com/contexts/inbox-signed-forged-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => object_id,
	+ "actor" => bob.ap_id,
	+ "attributedTo" => bob.ap_id,
	+ "context" => "https://two.com/contexts/inbox-signed-forged-create",
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ expect_signature_retry_from(alice)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("date", "Thu, 25 Jul 2024 13:33:31 GMT")
	+ \|> put_req_header("digest", "SHA-256=fake-digest")
	+ \|> put_req_header(
	+ "signature",
	+ "keyId=\"#{alice.ap_id}#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	+ )
	+ \|> post("/inbox", data)
	+
	+ assert conn.assigns.valid_signature == false
	+ assert "ok" == json_response(conn, 200)
	+
	+ assert [{:cancel, :actor_signature_mismatch}] =
	+ ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))
	+
	+ refute Activity.get_by_ap_id(data["id"])
	+ refute Object.get_by_ap_id(object_id)
	+ end
	+
	+ test "does not create a forged like signed by a different actor", %{conn: conn} do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ note = insert(:note)
	+
	+ data = %{
	+ "@context" => "https://www.w3.org/ns/activitystreams",
	+ "type" => "Like",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/inbox-signed-forged-like",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data["id"]
	+ }
	+
	+ expect_signature_retry_from(alice)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> put_req_header("date", "Thu, 25 Jul 2024 13:33:31 GMT")
	+ \|> put_req_header("digest", "SHA-256=fake-digest")
	+ \|> put_req_header(
	+ "signature",
	+ "keyId=\"#{alice.ap_id}#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"fake-signature\""
	+ )
	+ \|> post("/inbox", data)
	+
	+ assert conn.assigns.valid_signature == false
	+ assert "ok" == json_response(conn, 200)
	+
	+ assert [{:cancel, :actor_signature_mismatch}] =
	+ ObanHelpers.perform(all_enqueued(worker: SignatureRetryWorker))
	+
	+ refute Activity.get_by_ap_id(data["id"])
	+ end
	+
	test "accept follow activity", %{conn: conn} do
	clear_config([:instance, :federating], true)
	relay = Relay.get_actor()

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

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

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

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

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

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

	Mix.shell(Mix.Shell.Process)

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert all_enqueued() == []
	end)
	end

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

	+ actor =
	+ insert(:user, local: false, ap_id: "https://unknown.mastodon.instance/users/somebody")
	+
	Enum.each(unknown_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	- "actor" => "https://unknown.mastodon.instance/users/somebody"
	+ "actor" => actor.ap_id
	}
	\|> Jason.encode!()

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

	assert all_enqueued() == []
	end)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	[data: data]
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert json_response(conn, 403)
	end

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

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

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

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

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

	cc = [recipient.follower_address, actor.follower_address]

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

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

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

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

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

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

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

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

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

	assert json_response(ret_conn, 200)
	end

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

	note = insert(:note_activity, user: reported_user)

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

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

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

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

	ObanHelpers.perform_all()

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

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

	note = insert(:note_activity, user: reported_user)

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

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

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

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

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

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert result_next == result_next_again
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert json_response(conn, 200)
	end

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

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

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

	assert response(conn, 401)
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert json_response(conn, 400)
	end

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

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

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

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

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

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

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

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

	assert json_response(conn, 403)
	end

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

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

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

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

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

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

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

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

	assert json_response(conn, 400)
	end

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

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

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

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

	assert json_response(conn, 400)
	end

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

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

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

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

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

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

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

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

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

	refute user_object == user_object_new

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

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

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

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

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

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

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

	target_user_object_public_key = Map.fetch!(target_user_object, "publicKey")

	target_user_object_public_key =
	Map.put(target_user_object_public_key, "publicKeyPem", public_key)

	target_user_object_new =
	Map.put(target_user_object, "publicKey", target_user_object_public_key)

	refute target_user_object == target_user_object_new

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

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

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

	assert target_user_object == new_target_user_object
	assert json_response(conn, 403)
	end

	test "it rejects creating Actors of type Application", %{conn: conn} do
	user = insert(:user, local: true)

	data = %{
	type: "Create",
	object: %{
	type: "Application"
	}
	}

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

	assert json_response(conn, 400)
	end

	test "it rejects creating Actors of type Person", %{conn: conn} do
	user = insert(:user, local: true)

	data = %{
	type: "Create",
	object: %{
	type: "Person"
	}
	}

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

	assert json_response(conn, 400)
	end

	test "it rejects creating Actors of type Service", %{conn: conn} do
	user = insert(:user, local: true)

	data = %{
	type: "Create",
	object: %{
	type: "Service"
	}
	}

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

	assert json_response(conn, 400)
	end

	test "it rejects like activity to object invisible to actor", %{conn: conn} do
	user = insert(:user)
	stranger = insert(:user, local: true)
	{:ok, post} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, stranger)

	post_object = Object.normalize(post, fetch: false)

	data = %{
	type: "Like",
	object: %{
	id: post_object.data["id"]
	}
	}

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

	assert json_response(conn, 403)
	end

	test "it rejects announce activity to object invisible to actor", %{conn: conn} do
	user = insert(:user)
	stranger = insert(:user, local: true)
	{:ok, post} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, stranger)

	post_object = Object.normalize(post, fetch: false)

	data = %{
	type: "Announce",
	object: %{
	id: post_object.data["id"]
	}
	}

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

	assert json_response(conn, 403)
	end

	test "it rejects emojireact activity to object invisible to actor", %{conn: conn} do
	user = insert(:user)
	stranger = insert(:user, local: true)
	{:ok, post} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, stranger)

	post_object = Object.normalize(post, fetch: false)

	data = %{
	type: "EmojiReact",
	object: %{
	id: post_object.data["id"]
	},
	content: "😀"
	}

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

	assert json_response(conn, 403)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

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

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

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end

	test "it doesn't spreads faulty attributedTo or actor fields", %{
	conn: conn,
	activity: activity
	} do
	reimu = insert(:user, nickname: "reimu")
	cirno = insert(:user, nickname: "cirno")

	assert reimu.ap_id
	assert cirno.ap_id

	activity =
	activity
	\|> put_in(["object", "actor"], reimu.ap_id)
	\|> put_in(["object", "attributedTo"], reimu.ap_id)
	\|> put_in(["actor"], reimu.ap_id)
	\|> put_in(["attributedTo"], reimu.ap_id)

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

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

	assert cirno_outbox["attributedTo"] == nil
	assert cirno_outbox["actor"] == cirno.ap_id

	assert cirno_object = Object.normalize(cirno_outbox["object"], fetch: false)
	assert cirno_object.data["actor"] == cirno.ap_id
	assert cirno_object.data["attributedTo"] == cirno.ap_id
	end

	test "Character limitation", %{conn: conn, activity: activity} do
	clear_config([:instance, :limit], 5)
	user = insert(:user)

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

	assert result == "Character limit (5 characters) exceeded, contains 11 characters"
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

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

	conn
	\|> assign(:user, user)
	\|> get("/relay/followers")
	\|> json_response(404)
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end

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

	conn
	\|> assign(:user, user)
	\|> get("/relay/following")
	\|> json_response(404)
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user_two)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_followers: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{other_user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_followers: true)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additional ActivityPub C2S endpoints" do
	test "GET /api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

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

	conn
	\|> get("/api/ap/whoami")
	\|> json_response(403)
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	+ # majic's libmagic port is unavailable on local Darwin runs; Linux CI still runs this test.
	+ @tag :skip_darwin
	test "POST /api/ap/upload_media", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	object =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(:created)

	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	assert [%{"href" => object_href, "mediaType" => object_mediatype}] = object["url"]
	assert is_binary(object_href)
	assert object_mediatype == "image/jpeg"
	assert String.ends_with?(object_href, ".jpg")

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

	activity_response =
	conn
	\|> assign(:user, user)
	\|> post("/users/#{user.nickname}/outbox", activity_request)
	\|> json_response(:created)

	assert activity_response["id"]
	assert activity_response["object"]
	assert activity_response["actor"] == user.ap_id

	assert %Object{data: %{"attachment" => [attachment]}} =
	Object.normalize(activity_response["object"], fetch: false)

	assert attachment["type"] == "Document"
	assert attachment["name"] == desc

	assert [
	%{
	"href" => ^object_href,
	"type" => "Link",
	"mediaType" => ^object_mediatype
	}
	] = attachment["url"]

	# Fails if unauthenticated
	conn
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(403)
	end

	test "they don't work when C2S API is disabled", %{conn: conn} do
	clear_config([:activitypub, :client_api_enabled], false)

	user = insert(:user)

	assert conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")
	\|> response(403)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	assert conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> response(403)
	end
	end

	test "pinned collection", %{conn: conn} do
	clear_config([:instance, :max_pinned_statuses], 2)
	user = insert(:user)
	objects = insert_list(2, :note, user: user)

	Enum.reduce(objects, user, fn %{data: %{"id" => object_id}}, user ->
	{:ok, updated} = User.add_pinned_object_id(user, object_id)
	updated
	end)

	%{nickname: nickname, featured_address: featured_address, pinned_objects: pinned_objects} =
	refresh_record(user)

	%{"id" => ^featured_address, "orderedItems" => items, "totalItems" => 2} =
	conn
	\|> get("/users/#{nickname}/collections/featured")
	\|> json_response(200)

	object_ids = Enum.map(items, & &1["id"])

	assert Enum.all?(pinned_objects, fn {obj_id, _} ->
	obj_id in object_ids
	end)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs b/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs
	index 347c5b578..9dec315b3 100644
	--- a/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs
	@@ -1,168 +1,213 @@
	# 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.UpdateHandlingTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator

	import Pleroma.Factory

	describe "updates" do
	setup do
	user = insert(:user)

	object = %{
	"id" => user.ap_id,
	"name" => "A new name",
	"summary" => "A new bio"
	}

	{:ok, valid_update, []} = Builder.update(user, object)

	%{user: user, valid_update: valid_update}
	end

	test "validates a basic object", %{valid_update: valid_update} do
	assert {:ok, _update, []} = ObjectValidator.validate(valid_update, [])
	end

	- test "returns an error if the object can't be updated by the actor", %{
	+ test "returns an error if the object can't be updated by the actor (different domain)", %{
	valid_update: valid_update
	} do
	other_user = insert(:user, local: false)

	update =
	valid_update
	\|> Map.put("actor", other_user.ap_id)

	assert {:error, _cng} = ObjectValidator.validate(update, [])
	end

	- test "validates as long as the object is same-origin with the actor", %{
	+ test "returns an error if the object can't be updated by the actor (same domain)", %{
	+ user: user,
	valid_update: valid_update
	} do
	- other_user = insert(:user)
	+ user_ap_id = user.ap_id
	+ user_domain = URI.parse(user_ap_id).host
	+ other_user = insert(:user, local: false, domain: user_domain)

	update =
	valid_update
	\|> Map.put("actor", other_user.ap_id)

	- assert {:ok, _update, []} = ObjectValidator.validate(update, [])
	+ assert {:error, _cng} = ObjectValidator.validate(update, [])
	end

	- test "validates if the object is not of an Actor type" do
	- note = insert(:note)
	+ test "validates if the object is not of an Actor type", %{user: user} do
	+ note = insert(:note, user: user)
	updated_note = note.data \|> Map.put("content", "edited content")
	- other_user = insert(:user)

	- {:ok, update, _} = Builder.update(other_user, updated_note)
	+ {:ok, update, _} = Builder.update(user, updated_note)

	assert {:ok, _update, _} = ObjectValidator.validate(update, [])
	end
	+
	+ test "returns an error if the remote update target is unknown" do
	+ remote_user = insert(:user, local: false, ap_id: "https://example.com/users/alice")
	+
	+ update = %{
	+ "type" => "Update",
	+ "actor" => remote_user.ap_id,
	+ "id" => "https://example.com/activities/update-unknown-object",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://example.com/objects/unknown",
	+ "actor" => remote_user.ap_id,
	+ "content" => "edited content",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "updated" => "2024-07-25T13:34:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ assert {:error, %Ecto.Changeset{} = cng} = ObjectValidator.validate(update, local: false)
	+ refute cng.valid?
	+ assert Keyword.has_key?(cng.errors, :object)
	+ end
	+
	+ test "returns an error if the remote update target IRI is unknown" do
	+ remote_user = insert(:user, local: false, ap_id: "https://example.com/users/alice")
	+
	+ update = %{
	+ "type" => "Update",
	+ "actor" => remote_user.ap_id,
	+ "id" => "https://example.com/activities/update-unknown-object-iri",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => "https://example.com/objects/unknown-iri"
	+ }
	+
	+ assert {:error, %Ecto.Changeset{} = cng} = ObjectValidator.validate(update, local: false)
	+ refute cng.valid?
	+ assert Keyword.has_key?(cng.errors, :object)
	+ end
	end

	describe "update note" do
	test "converts object into Pleroma's format" do
	mastodon_tags = [
	%{
	"icon" => %{
	"mediaType" => "image/png",
	"type" => "Image",
	"url" => "https://somewhere.org/emoji/url/1.png"
	},
	"id" => "https://somewhere.org/emoji/1",
	"name" => ":some_emoji:",
	"type" => "Emoji",
	"updated" => "2021-04-07T11:00:00Z"
	}
	]

	user = insert(:user)
	note = insert(:note, user: user)

	updated_note =
	note.data
	\|> Map.put("content", "edited content")
	\|> Map.put("tag", mastodon_tags)

	{:ok, update, _} = Builder.update(user, updated_note)

	assert {:ok, _update, meta} = ObjectValidator.validate(update, [])

	assert %{"emoji" => %{"some_emoji" => "https://somewhere.org/emoji/url/1.png"}} =
	meta[:object_data]
	end

	test "returns no object_data in meta for a local Update" do
	user = insert(:user)
	note = insert(:note, user: user)

	updated_note =
	note.data
	\|> Map.put("content", "edited content")

	{:ok, update, _} = Builder.update(user, updated_note)

	assert {:ok, _update, meta} = ObjectValidator.validate(update, local: true)
	assert is_nil(meta[:object_data])
	end

	test "returns object_data in meta for a remote Update" do
	user = insert(:user)
	note = insert(:note, user: user)

	updated_note =
	note.data
	\|> Map.put("content", "edited content")

	{:ok, update, _} = Builder.update(user, updated_note)

	assert {:ok, _update, meta} = ObjectValidator.validate(update, local: false)
	assert meta[:object_data]

	assert {:ok, _update, meta} = ObjectValidator.validate(update, [])
	assert meta[:object_data]
	end
	end

	describe "update with history" do
	setup do
	user = insert(:user)
	{:ok, activity} = Pleroma.Web.CommonAPI.post(user, %{status: "mew mew :dinosaur:"})
	{:ok, edit} = Pleroma.Web.CommonAPI.update(activity, user, %{status: "edited :blank:"})
	{:ok, external_rep} = Pleroma.Web.ActivityPub.Transmogrifier.prepare_activity(edit.data)
	%{external_rep: external_rep}
	end

	test "edited note", %{external_rep: external_rep} do
	{:ok, _validate_res, meta} = ObjectValidator.validate(external_rep, [])

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"emoji" => %{"dinosaur" => _}}]}} =
	meta[:object_data]
	end

	test "edited note, badly-formed formerRepresentations", %{external_rep: external_rep} do
	external_rep = put_in(external_rep, ["object", "formerRepresentations"], %{})

	assert {:error, _} = ObjectValidator.validate(external_rep, [])
	end

	test "edited note, badly-formed history item", %{external_rep: external_rep} do
	history_item =
	Enum.at(external_rep["object"]["formerRepresentations"]["orderedItems"], 0)
	\|> Map.put("type", "Foo")

	external_rep =
	put_in(
	external_rep,
	["object", "formerRepresentations", "orderedItems"],
	[history_item]
	)

	assert {:error, _} = ObjectValidator.validate(external_rep, [])
	end
	end
	end
	diff --git a/test/pleroma/web/plugs/mapped_signature_to_identity_plug_test.exs b/test/pleroma/web/plugs/mapped_signature_to_identity_plug_test.exs
	index 33eff1bc5..df713762c 100644
	--- a/test/pleroma/web/plugs/mapped_signature_to_identity_plug_test.exs
	+++ b/test/pleroma/web/plugs/mapped_signature_to_identity_plug_test.exs
	@@ -1,59 +1,73 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.MappedSignatureToIdentityPlugTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.Plugs.MappedSignatureToIdentityPlug

	import Tesla.Mock
	import Plug.Conn

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	defp set_signature(conn, key_id) do
	conn
	\|> put_req_header("signature", "keyId=\"#{key_id}\"")
	\|> assign(:valid_signature, true)
	end

	test "it successfully maps a valid identity with a valid signature" do
	conn =
	build_conn(:get, "/doesntmattter")
	\|> set_signature("http://mastodon.example.org/users/admin")
	\|> MappedSignatureToIdentityPlug.call(%{})

	refute is_nil(conn.assigns.user)
	end

	test "it successfully maps a valid identity with a valid signature with payload" do
	conn =
	build_conn(:post, "/doesntmattter", %{"actor" => "http://mastodon.example.org/users/admin"})
	\|> set_signature("http://mastodon.example.org/users/admin")
	\|> MappedSignatureToIdentityPlug.call(%{})

	refute is_nil(conn.assigns.user)
	end

	test "it considers a mapped identity to be invalid when it mismatches a payload" do
	conn =
	build_conn(:post, "/doesntmattter", %{"actor" => "http://mastodon.example.org/users/admin"})
	\|> set_signature("https://niu.moe/users/rye")
	\|> MappedSignatureToIdentityPlug.call(%{})

	assert %{valid_signature: false} == conn.assigns
	end

	- @tag skip: "known breakage; the testsuite presently depends on it"
	test "it considers a mapped identity to be invalid when the identity cannot be found" do
	+ actor = "http://niu.moe/users/rye"
	+
	conn =
	- build_conn(:post, "/doesntmattter", %{"actor" => "http://mastodon.example.org/users/admin"})
	- \|> set_signature("http://niu.moe/users/rye")
	+ build_conn(:post, "/doesntmattter", %{"actor" => actor})
	+ \|> set_signature(actor)
	\|> MappedSignatureToIdentityPlug.call(%{})

	- assert %{valid_signature: false} == conn.assigns
	+ assert conn.assigns.valid_signature == false
	+ refute Map.has_key?(conn.assigns, :user)
	+ end
	+
	+ test "it considers a mapped identity to be invalid when embedded actor identity cannot be found" do
	+ actor = "http://niu.moe/users/rye"
	+
	+ conn =
	+ build_conn(:post, "/doesntmattter", %{"actor" => %{"id" => actor}})
	+ \|> set_signature(actor)
	+ \|> MappedSignatureToIdentityPlug.call(%{})
	+
	+ assert conn.assigns.valid_signature == false
	+ refute Map.has_key?(conn.assigns, :user)
	end
	end
	diff --git a/test/pleroma/workers/receiver_worker_test.exs b/test/pleroma/workers/receiver_worker_test.exs
	index 12abc1a27..ea05f38f1 100644
	--- a/test/pleroma/workers/receiver_worker_test.exs
	+++ b/test/pleroma/workers/receiver_worker_test.exs
	@@ -1,305 +1,324 @@
	# 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.Web.Federator
	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")

	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: [],
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	-
	- assert {:cancel, {:error, :forbidden}} = ReceiverWorker.perform(oban_job)
	+ 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")

	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: [],
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	-
	- assert {:cancel, {:error, :not_found}} = ReceiverWorker.perform(oban_job)
	+ 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")

	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: [],
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	-
	- assert {:cancel, {:error, :not_found}} = ReceiverWorker.perform(oban_job)
	+ 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)

	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: [],
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	-
	- assert {:cancel, {:user_active, false}} = ReceiverWorker.perform(oban_job)
	+ assert {:cancel, {:user_active, false}} = perform_incoming(params)
	end
	end

	- test "it can validate the signature" do
	- Tesla.Mock.mock(fn
	- %{url: "https://phpc.social/users/denniskoch"} ->
	- %Tesla.Env{
	- status: 200,
	- body: File.read!("test/fixtures/denniskoch.json"),
	- headers: [{"content-type", "application/activity+json"}]
	- }
	-
	- %{url: "https://phpc.social/users/denniskoch/collections/featured"} ->
	- %Tesla.Env{
	- status: 200,
	- headers: [{"content-type", "application/activity+json"}],
	- body:
	- File.read!("test/fixtures/users_mock/masto_featured.json")
	- \|> String.replace("{{domain}}", "phpc.social")
	- \|> String.replace("{{nickname}}", "denniskoch")
	- }
	- end)
	-
	- params =
	- File.read!("test/fixtures/receiver_worker_signature_activity.json") \|> Jason.decode!()
	-
	- req_headers = [
	- ["accept-encoding", "gzip"],
	- ["content-length", "5184"],
	- ["content-type", "application/activity+json"],
	- ["date", "Thu, 25 Jul 2024 13:33:31 GMT"],
	- ["digest", "SHA-256=ouge/6HP2/QryG6F3JNtZ6vzs/hSwMk67xdxe87eH7A="],
	- ["host", "bikeshed.party"],
	- [
	- "signature",
	- "keyId=\"https://mastodon.social/users/bastianallgeier#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"ymE3vn5Iw50N6ukSp8oIuXJB5SBjGAGjBasdTDvn+ahZIzq2SIJfmVCsIIzyqIROnhWyQoTbavTclVojEqdaeOx+Ejz2wBnRBmhz5oemJLk4RnnCH0lwMWyzeY98YAvxi9Rq57Gojuv/1lBqyGa+rDzynyJpAMyFk17XIZpjMKuTNMCbjMDy76ILHqArykAIL/v1zxkgwxY/+ELzxqMpNqtZ+kQ29znNMUBB3eVZ/mNAHAz6o33Y9VKxM2jw+08vtuIZOusXyiHbRiaj2g5HtN2WBUw1MzzfRfHF2/yy7rcipobeoyk5RvP5SyHV3WrIeZ3iyoNfmv33y8fxllF0EA==\""
	- ],
	- [
	- "user-agent",
	- "http.rb/5.2.0 (Mastodon/4.3.0-nightly.2024-07-25; +https://mastodon.social/)"
	- ]
	- ]
	-
	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: req_headers,
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	-
	- assert {:ok, %Pleroma.Activity{}} = ReceiverWorker.perform(oban_job)
	- end
	-
	test "cancels due to origin containment" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", "https://notorigindomain.com/activity")

	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: [],
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	-
	- assert {:cancel, :origin_containment_failed} = ReceiverWorker.perform(oban_job)
	+ 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)

	- {:ok, oban_job} =
	- Federator.incoming_ap_doc(%{
	- method: "POST",
	- req_headers: [],
	- request_path: "/inbox",
	- params: params,
	- query_string: ""
	- })
	+ 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, _} = ReceiverWorker.perform(oban_job)
	+ 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"})

	%{
	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/pleroma/workers/signature_retry_worker_test.exs b/test/pleroma/workers/signature_retry_worker_test.exs
	new file mode 100644
	index 000000000..94dd5f6c1
	--- /dev/null
	+++ b/test/pleroma/workers/signature_retry_worker_test.exs
	@@ -0,0 +1,574 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Workers.SignatureRetryWorkerTest do
	+ use Pleroma.DataCase, async: false
	+ use Oban.Testing, repo: Pleroma.Repo
	+
	+ import ExUnit.CaptureLog
	+ import Pleroma.Factory
	+
	+ @moduletag capture_log: true
	+
	+ alias Pleroma.Activity
	+ alias Pleroma.Object
	+ alias Pleroma.Signature
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.UserView
	+ alias Pleroma.Web.Federator
	+ alias Pleroma.Workers.SignatureRetryWorker
	+
	+ 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 stub_actor_fetch(%User{} = signer) do
	+ signer_json = UserView.render("user.json", %{user: signer}) \|> Map.delete("featured")
	+
	+ Tesla.Mock.mock(fn
	+ %{url: url} when url == signer.ap_id ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: Jason.encode!(signer_json),
	+ headers: HttpRequestMock.activitypub_object_headers()
	+ }
	+ end)
	+ end
	+
	+ defp expect_signature_from(%User{} = signer) do
	+ stub_actor_fetch(signer)
	+ Mox.expect(Pleroma.StubbedHTTPSignaturesMock, :validate_conn, fn _conn -> true end)
	+ end
	+
	+ defp enqueue_failed_signature(params, signer) do
	+ Federator.incoming_failed_signature_ap_doc(%{
	+ method: "POST",
	+ req_headers: signature_headers_for(signer),
	+ request_path: "/inbox",
	+ params: params,
	+ query_string: ""
	+ })
	+ end
	+
	+ defp failed_signature_job(params, req_headers, opts \\ []) do
	+ %Oban.Job{
	+ args: %{
	+ "op" => "incoming_failed_signature_ap_doc",
	+ "method" => Keyword.get(opts, :method, "POST"),
	+ "req_headers" => req_headers,
	+ "request_path" => Keyword.get(opts, :request_path, "/inbox"),
	+ "params" => params,
	+ "query_string" => Keyword.get(opts, :query_string, "")
	+ }
	+ }
	+ end
	+
	+ defp assert_mismatched_signature_cancelled(params, signer) do
	+ assert {:ok, oban_job} = enqueue_failed_signature(params, signer)
	+
	+ capture_log([level: :warning], fn ->
	+ assert {:cancel, :actor_signature_mismatch} = SignatureRetryWorker.perform(oban_job)
	+ end)
	+ end
	+
	+ test "Federator preserves request metadata for failed-signature retry jobs" do
	+ params = insert(:note_activity).data
	+
	+ req_headers = [
	+ {"host", "local.test"},
	+ {"signature", "keyId=\"https://one.com/users/alice#main-key\""}
	+ ]
	+
	+ assert {:ok, oban_job} =
	+ Federator.incoming_failed_signature_ap_doc(%{
	+ method: "POST",
	+ req_headers: req_headers,
	+ request_path: "/inbox",
	+ params: params,
	+ query_string: "foo=bar"
	+ })
	+
	+ assert oban_job.worker == "Pleroma.Workers.SignatureRetryWorker"
	+
	+ assert %{
	+ "op" => "incoming_failed_signature_ap_doc",
	+ "method" => "POST",
	+ "req_headers" => ^req_headers,
	+ "request_path" => "/inbox",
	+ "params" => ^params,
	+ "query_string" => "foo=bar"
	+ } = oban_job.args
	+ end
	+
	+ test "cancels retry jobs without request metadata" do
	+ params = insert(:note_activity).data
	+
	+ log =
	+ capture_log([level: :warning], fn ->
	+ assert {:cancel, :missing_signature_retry_metadata} =
	+ SignatureRetryWorker.perform(%Oban.Job{
	+ args: %{"op" => "incoming_failed_signature_ap_doc", "params" => params}
	+ })
	+ end)
	+
	+ assert log =~ "Failed-signature inbox retry rejected"
	+ assert log =~ "reason=:missing_signature_retry_metadata"
	+ assert log =~ "payload_actor=#{inspect(params["actor"])}"
	+ assert log =~ "activity_id=#{inspect(params["id"])}"
	+ assert log =~ "type=#{inspect(params["type"])}"
	+ assert log =~ "request_path=nil"
	+ end
	+
	+ test "cancels retry jobs with malformed serialized request headers" do
	+ params = insert(:note_activity).data
	+
	+ log =
	+ capture_log([level: :warning], fn ->
	+ assert {:cancel, :invalid_signature_retry_metadata} =
	+ SignatureRetryWorker.perform(failed_signature_job(params, [["signature"]]))
	+ end)
	+
	+ assert log =~ "Failed-signature inbox retry rejected"
	+ assert log =~ "reason=:invalid_signature_retry_metadata"
	+ assert log =~ "signature_actor=nil"
	+ assert log =~ "request_path=\"/inbox\""
	+ end
	+
	+ test "cancels retry jobs without a signature header" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ params = insert(:note_activity, user: alice).data
	+
	+ log =
	+ capture_log([level: :warning], fn ->
	+ assert {:cancel, :invalid_signature} =
	+ SignatureRetryWorker.perform(
	+ failed_signature_job(params, [{"host", "local.test"}])
	+ )
	+ end)
	+
	+ assert log =~ "Failed-signature inbox retry rejected"
	+ assert log =~ "reason=:invalid_signature"
	+ assert log =~ "payload_actor=#{inspect(params["actor"])}"
	+ assert log =~ "signature_actor=nil"
	+ assert log =~ "request_path=\"/inbox\""
	+ end
	+
	+ test "cancels missing signature before fetching an unavailable payload actor" do
	+ params =
	+ insert(:note_activity).data
	+ \|> Map.put("actor", "https://unavailable.example/users/bob")
	+
	+ assert {:cancel, :invalid_signature} =
	+ SignatureRetryWorker.perform(failed_signature_job(params, [{"host", "local.test"}]))
	+ end
	+
	+ test "cancels signer mismatch before fetching an unavailable payload actor" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+
	+ params =
	+ insert(:note_activity).data
	+ \|> Map.put("actor", "https://unavailable.example/users/bob")
	+
	+ assert {:cancel, :actor_signature_mismatch} =
	+ SignatureRetryWorker.perform(
	+ failed_signature_job(params, signature_headers_for(alice))
	+ )
	+ end
	+
	+ test "cancels retry jobs with a signature header without keyId" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ params = insert(:note_activity, user: alice).data
	+
	+ req_headers = [{"signature", "algorithm=\"rsa-sha256\",signature=\"fake-signature\""}]
	+
	+ assert {:cancel, :invalid_signature} =
	+ SignatureRetryWorker.perform(failed_signature_job(params, req_headers))
	+ end
	+
	+ test "cancels retry jobs with an unparsable signature keyId" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ params = insert(:note_activity, user: alice).data
	+ req_headers = [{"signature", "keyId=\"not an activitypub id\",signature=\"fake-signature\""}]
	+
	+ assert {:cancel, :invalid_signature} =
	+ SignatureRetryWorker.perform(failed_signature_job(params, req_headers))
	+ end
	+
	+ test "cancels when the refetched key still cannot validate the signature" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => alice.ap_id,
	+ "id" => "https://one.com/activities/invalid-signature-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://one.com/objects/invalid-signature-note",
	+ "actor" => alice.ap_id,
	+ "attributedTo" => alice.ap_id,
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ stub_actor_fetch(alice)
	+
	+ assert {:ok, oban_job} = enqueue_failed_signature(create, alice)
	+
	+ log =
	+ capture_log([level: :warning], fn ->
	+ assert {:cancel, :invalid_signature} = SignatureRetryWorker.perform(oban_job)
	+ end)
	+
	+ assert log =~ "Failed-signature inbox retry rejected"
	+ assert log =~ "reason=:invalid_signature"
	+ assert log =~ "payload_actor=\"https://one.com/users/alice\""
	+ assert log =~ "signature_actor=\"https://one.com/users/alice\""
	+ assert log =~ "activity_id=\"https://one.com/activities/invalid-signature-create\""
	+ assert log =~ "type=\"Create\""
	+ assert log =~ "request_path=\"/inbox\""
	+
	+ refute Activity.get_by_ap_id(create["id"])
	+ end
	+
	+ test "processes the activity after refetching a valid matching signature" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => alice.ap_id,
	+ "id" => "https://one.com/activities/valid-signature-create",
	+ "context" => "https://one.com/contexts/valid-signature-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://one.com/objects/valid-signature-note",
	+ "actor" => alice.ap_id,
	+ "attributedTo" => alice.ap_id,
	+ "context" => "https://one.com/contexts/valid-signature-create",
	+ "content" => "valid post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ expect_signature_from(alice)
	+
	+ assert {:ok, oban_job} = enqueue_failed_signature(create, alice)
	+ assert {:ok, %Activity{}} = SignatureRetryWorker.perform(oban_job)
	+ assert Activity.get_by_ap_id(create["id"])
	+ end
	+
	+ test "processes the activity when a real signature validates with a query string" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => alice.ap_id,
	+ "id" => "https://one.com/activities/valid-query-signature-create",
	+ "context" => "https://one.com/contexts/valid-query-signature-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://one.com/objects/valid-query-signature-note",
	+ "actor" => alice.ap_id,
	+ "attributedTo" => alice.ap_id,
	+ "context" => "https://one.com/contexts/valid-query-signature-create",
	+ "content" => "valid signed post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ stub_actor_fetch(alice)
	+
	+ date = "Thu, 25 Jul 2024 13:33:31 GMT"
	+ digest = "SHA-256=fake-digest"
	+
	+ signature =
	+ Signature.sign(alice, %{
	+ "(request-target)" => "post /inbox?foo=bar",
	+ "content-type" => "application/activity+json",
	+ date: date,
	+ digest: digest,
	+ host: "local.test"
	+ })
	+
	+ req_headers = [
	+ ["host", "local.test"],
	+ ["date", date],
	+ ["digest", digest],
	+ ["content-type", "application/activity+json"],
	+ ["signature", signature]
	+ ]
	+
	+ assert {:ok, %Activity{}} =
	+ SignatureRetryWorker.perform(
	+ failed_signature_job(create, req_headers, query_string: "foo=bar")
	+ )
	+
	+ assert Activity.get_by_ap_id(create["id"])
	+ end
	+
	+ test "cancels when signature actor does not match payload actor" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+
	+ note =
	+ insert(:note,
	+ user: bob,
	+ object_local: false,
	+ data: %{"id" => "https://two.com/objects/malicious-update-note"}
	+ )
	+
	+ update = %{
	+ "type" => "Update",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/malicious-update",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data
	+ }
	+
	+ assert_mismatched_signature_cancelled(update, alice)
	+ end
	+
	+ test "cancels signature actor mismatch through Federator-created jobs" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+
	+ note =
	+ insert(:note,
	+ user: bob,
	+ object_local: false,
	+ data: %{"id" => "https://two.com/objects/federator-malicious-note"}
	+ )
	+
	+ update = %{
	+ "type" => "Update",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/federator-malicious-update",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data
	+ }
	+
	+ assert_mismatched_signature_cancelled(update, alice)
	+ end
	+
	+ test "cancels signature actor mismatch before processing a forged Create" 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")
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/forged-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://two.com/objects/forged-note",
	+ "actor" => bob.ap_id,
	+ "attributedTo" => bob.ap_id,
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ assert_mismatched_signature_cancelled(create, alice)
	+ end
	+
	+ test "cancels signature actor mismatch when payload actor is embedded" 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")
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => %{"id" => bob.ap_id},
	+ "id" => "https://two.com/activities/embedded-actor-forged-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://two.com/objects/embedded-actor-forged-note",
	+ "actor" => bob.ap_id,
	+ "attributedTo" => bob.ap_id,
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ assert_mismatched_signature_cancelled(create, alice)
	+ end
	+
	+ test "logs signature actor mismatch retry rejections" 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")
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/logged-forged-create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => %{
	+ "type" => "Note",
	+ "id" => "https://two.com/objects/logged-forged-note",
	+ "actor" => bob.ap_id,
	+ "attributedTo" => bob.ap_id,
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ log = assert_mismatched_signature_cancelled(create, alice)
	+
	+ assert log =~ "Failed-signature inbox retry rejected"
	+ assert log =~ "reason=:actor_signature_mismatch"
	+ assert log =~ "payload_actor=\"https://two.com/users/bob\""
	+ assert log =~ "signature_actor=\"https://one.com/users/alice\""
	+ assert log =~ "activity_id=\"https://two.com/activities/logged-forged-create\""
	+ assert log =~ "type=\"Create\""
	+ assert log =~ "request_path=\"/inbox\""
	+ end
	+
	+ test "cancels signature actor mismatch before actually creating a forged post" 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/actually-forged-note"
	+
	+ create = %{
	+ "type" => "Create",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/actually-forged-create",
	+ "context" => "https://two.com/contexts/actually-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/actually-forged-create",
	+ "content" => "forged post",
	+ "published" => "2024-07-25T13:33:31Z",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => []
	+ }
	+ }
	+
	+ assert_mismatched_signature_cancelled(create, alice)
	+ refute Object.get_by_ap_id(object_id)
	+ end
	+
	+ test "cancels signature actor mismatch before processing a forged Like" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ note = insert(:note)
	+
	+ like = %{
	+ "type" => "Like",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/forged-like",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data["id"]
	+ }
	+
	+ assert_mismatched_signature_cancelled(like, alice)
	+ end
	+
	+ test "cancels signature actor mismatch before actually creating a forged Like" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ note = insert(:note)
	+
	+ like = %{
	+ "type" => "Like",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/actually-forged-like",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data["id"]
	+ }
	+
	+ assert_mismatched_signature_cancelled(like, alice)
	+ refute Activity.get_by_ap_id(like["id"])
	+ end
	+
	+ test "cancels signature actor mismatch before processing a forged Announce" do
	+ alice = insert(:user, local: false, ap_id: "https://one.com/users/alice")
	+ bob = insert(:user, local: false, ap_id: "https://two.com/users/bob")
	+ note = insert(:note)
	+
	+ announce = %{
	+ "type" => "Announce",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/forged-announce",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => note.data["id"]
	+ }
	+
	+ assert_mismatched_signature_cancelled(announce, alice)
	+ end
	+
	+ test "cancels signature actor mismatch before processing a forged Follow" 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")
	+ followed = insert(:user)
	+
	+ follow = %{
	+ "type" => "Follow",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/forged-follow",
	+ "to" => [followed.ap_id],
	+ "cc" => [],
	+ "object" => followed.ap_id
	+ }
	+
	+ assert_mismatched_signature_cancelled(follow, alice)
	+ end
	+
	+ test "cancels signature actor mismatch before processing a forged Undo" 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")
	+
	+ undo = %{
	+ "type" => "Undo",
	+ "actor" => bob.ap_id,
	+ "id" => "https://two.com/activities/forged-undo",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "cc" => [],
	+ "object" => "https://two.com/activities/existing-bob-activity"
	+ }
	+
	+ assert_mismatched_signature_cancelled(undo, alice)
	+ end
	+end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Oct 12, 9:15 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786111
Default Alt Text: (354 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions