No OneTemporary
Actions

Size

658 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.woodpecker/test.yml b/.woodpecker/test.yml
	index 66b4a2b33..be8ea0dfa 100644
	--- a/.woodpecker/test.yml
	+++ b/.woodpecker/test.yml
	@@ -1,113 +1,114 @@
	platform: linux/amd64

	matrix:
	ELIXIR_VERSION:
	- 1.14
	- 1.15
	OTP_VERSION:
	- 25
	- 26
	include:
	- ELIXIR_VERSION: 1.14
	OTP_VERSION: 25
	- ELIXIR_VERSION: 1.15
	OTP_VERSION: 25
	# Soon
	#- ELIXIR_VERSION: 1.15
	# OTP_VERSION: 26

	variables:
	- &scw-secrets
	- SCW_ACCESS_KEY
	- SCW_SECRET_KEY
	- SCW_DEFAULT_ORGANIZATION_ID
	- &setup-hex "mix local.hex --force && mix local.rebar --force"
	- &on-release
	when:
	event:
	- push
	- tag
	branch:
	- develop
	- stable
	- refs/tags/v*
	- refs/tags/stable-*
	- &on-stable
	when:
	event:
	- push
	- tag
	branch:
	- stable
	- refs/tags/stable-*
	- &on-point-release
	when:
	event:
	- push
	branch:
	- develop
	- stable
	- &on-pr-open
	when:
	event:
	- pull_request

	- &tag-build "export BUILD_TAG=$${CI_COMMIT_TAG:-\"$CI_COMMIT_BRANCH\"} && export PLEROMA_BUILD_BRANCH=$BUILD_TAG"

	- &clean "(rm -rf release \|\| true) && (rm -rf _build \|\| true) && (rm -rf /root/.mix)"
	- &mix-clean "mix deps.clean --all && mix clean"

	services:
	postgres:
	image: postgres:15
	when:
	event:
	- pull_request
	environment:
	POSTGRES_DB: pleroma_test_${ELIXIR_VERSION}_${OTP_VERSION}
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres

	pipeline:
	lint:
	<<: *on-pr-open
	image: akkoma/ci-base:1.15
	commands:
	- mix local.hex --force
	- mix local.rebar --force
	- mix format --check-formatted

	build:
	image: akkoma/ci-base:${ELIXIR_VERSION}-otp${OTP_VERSION}
	<<: *on-pr-open
	environment:
	MIX_ENV: test
	POSTGRES_DB: pleroma_test_${ELIXIR_VERSION}_${OTP_VERSION}
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	commands:
	- mix local.hex --force
	- mix local.rebar --force
	- mix deps.get
	- mix compile

	test:
	image: akkoma/ci-base:${ELIXIR_VERSION}-otp${OTP_VERSION}
	<<: *on-pr-open
	environment:
	MIX_ENV: test
	POSTGRES_DB: pleroma_test_${ELIXIR_VERSION}_${OTP_VERSION}
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	commands:
	- mix local.hex --force
	- mix local.rebar --force
	- mix deps.get
	- mix compile
	- mix ecto.drop -f -q
	- mix ecto.create
	- mix ecto.migrate
	- mkdir -p test/tmp
	- - mix test --preload-modules --exclude erratic --exclude federated
	+ - mix test --preload-modules --exclude erratic --exclude federated --exclude mocked
	+ - mix test --preload-modules --only mocked
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index aeaf05986..9e62ca69f 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,311 +1,316 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Fetcher do
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.Signature
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Federator

	require Logger
	require Pleroma.Constants

	defp touch_changeset(changeset) do
	updated_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)

	Ecto.Changeset.put_change(changeset, :updated_at, updated_at)
	end

	defp maybe_reinject_internal_fields(%{data: %{} = old_data}, new_data) do
	has_history? = fn
	%{"formerRepresentations" => %{"orderedItems" => list}} when is_list(list) -> true
	_ -> false
	end

	internal_fields = Map.take(old_data, Pleroma.Constants.object_internal_fields())

	remote_history_exists? = has_history?.(new_data)

	# If the remote history exists, we treat that as the only source of truth.
	new_data =
	if has_history?.(old_data) and not remote_history_exists? do
	Map.put(new_data, "formerRepresentations", old_data["formerRepresentations"])
	else
	new_data
	end

	# If the remote does not have history information, we need to manage it ourselves
	new_data =
	if not remote_history_exists? do
	changed? =
	Pleroma.Constants.status_updatable_fields()
	\|> Enum.any?(fn field -> Map.get(old_data, field) != Map.get(new_data, field) end)

	%{updated_object: updated_object} =
	new_data
	\|> Object.Updater.maybe_update_history(old_data,
	updated: changed?,
	use_history_in_new_object?: false
	)

	updated_object
	else
	new_data
	end

	Map.merge(new_data, internal_fields)
	end

	defp maybe_reinject_internal_fields(_, new_data), do: new_data

	@spec reinject_object(struct(), map()) :: {:ok, Object.t()} \| {:error, any()}
	defp reinject_object(%Object{data: %{"type" => "Question"}} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with data <- maybe_reinject_internal_fields(object, new_data),
	{:ok, data, _} <- ObjectValidator.validate(data, %{}),
	changeset <- Object.change(object, %{data: data}),
	changeset <- touch_changeset(changeset),
	{:ok, object} <- Repo.insert_or_update(changeset),
	{:ok, object} <- Object.set_cache(object) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	defp reinject_object(%Object{} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with new_data <- Transmogrifier.fix_object(new_data),
	data <- maybe_reinject_internal_fields(object, new_data),
	changeset <- Object.change(object, %{data: data}),
	changeset <- touch_changeset(changeset),
	{:ok, object} <- Repo.insert_or_update(changeset),
	{:ok, object} <- Object.set_cache(object) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	def refetch_object(%Object{data: %{"id" => id}} = object) do
	with {:local, false} <- {:local, Object.local?(object)},
	{:ok, new_data} <- fetch_and_contain_remote_object_from_id(id),
	{:ok, object} <- reinject_object(object, new_data) do
	{:ok, object}
	else
	{:local, true} -> {:ok, object}
	e -> {:error, e}
	end
	end

	# Note: will create a Create activity, which we need internally at the moment.
	def fetch_object_from_id(id, options \\ []) do
	with %URI{} = uri <- URI.parse(id),
	+ # let's check the URI is even vaguely valid first
	+ {:scheme, true} <- {:scheme, uri.scheme == "http" or uri.scheme == "https"},
	# If we have instance restrictions, apply them here to prevent fetching from unwanted instances
	{:ok, nil} <- Pleroma.Web.ActivityPub.MRF.SimplePolicy.check_reject(uri),
	{:ok, _} <- Pleroma.Web.ActivityPub.MRF.SimplePolicy.check_accept(uri),
	{_, nil} <- {:fetch_object, Object.get_cached_by_ap_id(id)},
	{_, true} <- {:allowed_depth, Federator.allowed_thread_distance?(options[:depth])},
	{_, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
	{_, nil} <- {:normalize, Object.normalize(data, fetch: false)},
	params <- prepare_activity_params(data),
	{_, :ok} <- {:containment, Containment.contain_origin(id, params)},
	{_, {:ok, activity}} <-
	{:transmogrifier, Transmogrifier.handle_incoming(params, options)},
	{_, _data, %Object{} = object} <-
	{:object, data, Object.normalize(activity, fetch: false)} do
	{:ok, object}
	else
	{:allowed_depth, false} ->
	{:error, "Max thread distance exceeded."}

	+ {:scheme, false} ->
	+ {:error, "URI Scheme Invalid"}
	+
	{:containment, _} ->
	{:error, "Object containment failed."}

	{:transmogrifier, {:error, {:reject, e}}} ->
	{:reject, e}

	{:transmogrifier, {:reject, e}} ->
	{:reject, e}

	{:transmogrifier, _} = e ->
	{:error, e}

	{:object, data, nil} ->
	reinject_object(%Object{}, data)

	{:normalize, object = %Object{}} ->
	{:ok, object}

	{:fetch_object, %Object{} = object} ->
	{:ok, object}

	{:fetch, {:error, error}} ->
	{:error, error}

	{:reject, reason} ->
	{:reject, reason}

	e ->
	e
	end
	end

	defp prepare_activity_params(data) do
	%{
	"type" => "Create",
	# Should we seriously keep this attributedTo thing?
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	}
	\|> Maps.put_if_present("to", data["to"])
	\|> Maps.put_if_present("cc", data["cc"])
	\|> Maps.put_if_present("bto", data["bto"])
	\|> Maps.put_if_present("bcc", data["bcc"])
	end

	def fetch_object_from_id!(id, options \\ []) do
	with {:ok, object} <- fetch_object_from_id(id, options) do
	object
	else
	{:error, %Tesla.Mock.Error{}} ->
	nil

	{:error, {"Object has been deleted", _id, _code}} ->
	nil

	{:reject, reason} ->
	Logger.debug("Rejected #{id} while fetching: #{inspect(reason)}")
	nil

	e ->
	Logger.error("Error while fetching #{id}: #{inspect(e)}")
	nil
	end
	end

	defp make_signature(id, date) do
	uri = URI.parse(id)

	signature =
	InternalFetchActor.get_actor()
	\|> Signature.sign(%{
	"(request-target)": "get #{uri.path}",
	host: uri.host,
	date: date
	})

	{"signature", signature}
	end

	defp sign_fetch(headers, id, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[make_signature(id, date) \| headers]
	else
	headers
	end
	end

	defp maybe_date_fetch(headers, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[{"date", date} \| headers]
	else
	headers
	end
	end

	def fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(%{"id" => id}),
	do: fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
	Logger.debug("Fetching object #{id} via AP")

	with {:scheme, true} <- {:scheme, String.starts_with?(id, "http")},
	{:ok, body} <- get_object(id),
	{:ok, data} <- safe_json_decode(body),
	:ok <- Containment.contain_origin_from_id(id, data) do
	unless Instances.reachable?(id) do
	Instances.set_reachable(id)
	end

	{:ok, data}
	else
	{:scheme, _} ->
	{:error, "Unsupported URI scheme"}

	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	def fetch_and_contain_remote_object_from_id(_id),
	do: {:error, "id must be a string"}

	def get_object(id) do
	date = Pleroma.Signature.signed_date()

	headers =
	[{"accept", "application/activity+json"}]
	\|> maybe_date_fetch(date)
	\|> sign_fetch(id, date)

	case HTTP.get(id, headers) do
	{:ok, %{body: body, status: code, headers: headers}} when code in 200..299 ->
	case List.keyfind(headers, "content-type", 0) do
	{_, content_type} ->
	case Plug.Conn.Utils.media_type(content_type) do
	{:ok, "application", "activity+json", _} ->
	{:ok, body}

	{:ok, "application", "ld+json",
	%{"profile" => "https://www.w3.org/ns/activitystreams"}} ->
	{:ok, body}

	# pixelfed sometimes (and only sometimes) responds with http instead of https
	{:ok, "application", "ld+json",
	%{"profile" => "http://www.w3.org/ns/activitystreams"}} ->
	{:ok, body}

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

	_ ->
	{:error, {:content_type, nil}}
	end

	{:ok, %{status: code}} when code in [404, 410] ->
	{:error, {"Object has been deleted", id, code}}

	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	defp safe_json_decode(nil), do: {:ok, nil}
	defp safe_json_decode(json), do: Jason.decode(json)
	end
	diff --git a/test/mix/tasks/pleroma/ecto/migrate_test.exs b/test/mix/tasks/pleroma/ecto/migrate_test.exs
	index 3bfdde1c0..d60a172ff 100644
	--- a/test/mix/tasks/pleroma/ecto/migrate_test.exs
	+++ b/test/mix/tasks/pleroma/ecto/migrate_test.exs
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-onl

	defmodule Mix.Tasks.Pleroma.Ecto.MigrateTest do
	use Pleroma.DataCase
	import ExUnit.CaptureLog
	require Logger

	test "ecto.migrate info message" do
	level = Logger.level()
	- Logger.configure(level: :warn)
	+ Logger.configure(level: :warning)

	assert capture_log(fn ->
	Mix.Tasks.Pleroma.Ecto.Migrate.run()
	end) =~ "[info] Migrations already up"

	Logger.configure(level: level)
	end
	end
	diff --git a/test/mix/tasks/pleroma/uploads_test.exs b/test/mix/tasks/pleroma/uploads_test.exs
	index 5976255e1..4a6800099 100644
	--- a/test/mix/tasks/pleroma/uploads_test.exs
	+++ b/test/mix/tasks/pleroma/uploads_test.exs
	@@ -1,58 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.UploadsTest do
	alias Pleroma.Upload
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	import Mock

	setup_all do
	Mix.shell(Mix.Shell.Process)

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

	File.mkdir_p!("test/uploads")

	:ok
	end

	describe "running migrate_local" do
	test "uploads migrated" do
	with_mock Upload,
	store: fn %Upload{name: _file, path: _path}, _opts -> {:ok, %{}} end do
	Mix.Tasks.Pleroma.Uploads.run(["migrate_local", "S3"])

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Migrating files from local"

	assert_receive {:mix_shell, :info, [message]}

	assert %{"total_count" => total_count} =
	Regex.named_captures(~r"^Found (?<total_count>\d+) uploads$", message)

	assert_receive {:mix_shell, :info, [message]}

	# @logevery in Mix.Tasks.Pleroma.Uploads
	count =
	min(50, String.to_integer(total_count))
	\|> to_string()

	assert %{"count" => ^count, "total_count" => ^total_count} =
	Regex.named_captures(
	~r"^Uploaded (?<count>\d+)/(?<total_count>\d+) files$",
	message
	)
	end
	end

	test "nonexistent uploader" do
	assert_raise RuntimeError, ~r/The uploader .* is not an existing/, fn ->
	Mix.Tasks.Pleroma.Uploads.run(["migrate_local", "nonexistent"])
	end
	end
	end
	end
	diff --git a/test/mix/tasks/pleroma/user_test.exs b/test/mix/tasks/pleroma/user_test.exs
	index 219490708..414b87bec 100644
	--- a/test/mix/tasks/pleroma/user_test.exs
	+++ b/test/mix/tasks/pleroma/user_test.exs
	@@ -1,620 +1,621 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.MFA
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo
	+ @moduletag :mocked

	import ExUnit.CaptureIO
	import Mock
	import Pleroma.Factory

	setup_all do
	Mix.shell(Mix.Shell.Process)

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

	:ok
	end

	describe "running new" do
	test "user is created" do
	# just get random data
	unsaved = build(:user)

	# prepare to answer yes
	send(self(), {:mix_shell_input, :prompt, "Y"})

	Mix.Tasks.Pleroma.User.run([
	"new",
	unsaved.nickname,
	unsaved.email,
	"--name",
	unsaved.name,
	"--bio",
	unsaved.bio,
	"--password",
	"test",
	"--moderator",
	"--admin"
	])

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_receive {:mix_shell, :prompt, [message]}
	assert message =~ "Continue"

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "created"

	user = User.get_cached_by_nickname(unsaved.nickname)
	assert user.name == unsaved.name
	assert user.email == unsaved.email
	assert user.bio == unsaved.bio
	assert user.is_moderator
	assert user.is_admin
	end

	test "user is not created" do
	unsaved = build(:user)

	# prepare to answer no
	send(self(), {:mix_shell_input, :prompt, "N"})

	Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_receive {:mix_shell, :prompt, [message]}
	assert message =~ "Continue"

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "will not be created"

	refute User.get_cached_by_nickname(unsaved.nickname)
	end
	end

	describe "running rm" do
	test "user is deleted" do
	clear_config([:instance, :federating], true)
	user = insert(:user)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
	ObanHelpers.perform_all()

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ " deleted"
	assert %{is_active: false} = User.get_by_nickname(user.nickname)

	assert called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "a remote user's create activity is deleted when the object has been pruned" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "uguu"})
	{:ok, post2} = CommonAPI.post(user2, %{status: "test"})
	obj = Object.normalize(post2, fetch: false)

	{:ok, like_object, meta} = Pleroma.Web.ActivityPub.Builder.like(user, obj)

	{:ok, like_activity, _meta} =
	Pleroma.Web.ActivityPub.Pipeline.common_pipeline(
	like_object,
	Keyword.put(meta, :local, true)
	)

	like_activity.data["object"]
	\|> Pleroma.Object.get_by_ap_id()
	\|> Repo.delete()

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

	object = Object.normalize(post, fetch: false)
	Object.prune(object)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
	ObanHelpers.perform_all()

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ " deleted"
	assert %{is_active: false} = User.get_by_nickname(user.nickname)

	assert called(Pleroma.Web.Federator.publish(:_))
	refute Pleroma.Repo.get(Pleroma.Activity, like_activity.id)
	end

	refute Activity.get_by_id(post.id)
	end

	test "no user to delete" do
	Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running deactivate" do
	test "active user is deactivated and unsubscribed" do
	followed = insert(:user)
	remote_followed = insert(:user, local: false)
	user = insert(:user)

	User.follow(user, followed, :follow_accept)
	User.follow(user, remote_followed, :follow_accept)

	Mix.Tasks.Pleroma.User.run(["deactivate", user.nickname])

	# Note that the task has delay :timer.sleep(500)
	assert_receive {:mix_shell, :info, [message]}

	assert message ==
	"Successfully deactivated #{user.nickname} and unsubscribed all local followers"

	user = User.get_cached_by_nickname(user.nickname)
	assert Enum.empty?(Enum.filter(User.get_friends(user), & &1.local))
	refute user.is_active
	end

	test "user is deactivated" do
	%{id: id, nickname: nickname} = insert(:user, is_active: false)

	assert :ok = Mix.Tasks.Pleroma.User.run(["deactivate", nickname])
	assert_receive {:mix_shell, :info, [message]}
	assert message == "User #{nickname} already deactivated"

	user = Repo.get(User, id)
	refute user.is_active
	end

	test "no user to deactivate" do
	Mix.Tasks.Pleroma.User.run(["deactivate", "nonexistent"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running set" do
	test "All statuses set" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run([
	"set",
	user.nickname,
	"--admin",
	"--confirmed",
	"--locked",
	"--moderator"
	])

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* true/

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Confirmation status.* true/

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* true/

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* true/

	user = User.get_cached_by_nickname(user.nickname)
	assert user.is_moderator
	assert user.is_locked
	assert user.is_admin
	assert user.is_confirmed
	end

	test "All statuses unset" do
	user =
	insert(:user,
	is_locked: true,
	is_moderator: true,
	is_admin: true,
	is_confirmed: false
	)

	Mix.Tasks.Pleroma.User.run([
	"set",
	user.nickname,
	"--no-admin",
	"--no-confirmed",
	"--no-locked",
	"--no-moderator"
	])

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* false/

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Confirmation status.* false/

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* false/

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* false/

	user = User.get_cached_by_nickname(user.nickname)
	refute user.is_moderator
	refute user.is_locked
	refute user.is_admin
	refute user.is_confirmed
	end

	test "no user to set status" do
	Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running reset_password" do
	test "password reset token is generated" do
	user = insert(:user)

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
	end) =~ "URL:"

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Generated"
	end

	test "no user to reset password" do
	Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running reset_mfa" do
	test "disables MFA" do
	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: "xx", confirmed: true}
	}
	)

	Mix.Tasks.Pleroma.User.run(["reset_mfa", user.nickname])

	assert_receive {:mix_shell, :info, [message]}
	assert message == "Multi-Factor Authentication disabled for #{user.nickname}"

	assert %{enabled: false, totp: false} ==
	user.nickname
	\|> User.get_cached_by_nickname()
	\|> MFA.mfa_settings()
	end

	test "no user to reset MFA" do
	Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running invite" do
	test "invite token is generated" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["invite"])
	end) =~ "http"

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token one time"
	end

	test "token is generated with expires_at" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--expires-at",
	Date.to_string(Date.utc_today())
	])
	end)

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token date limited"
	end

	test "token is generated with max use" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--max-use",
	"5"
	])
	end)

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token reusable"
	end

	test "token is generated with max use and expires date" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--max-use",
	"5",
	"--expires-at",
	Date.to_string(Date.utc_today())
	])
	end)

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token reusable date limited"
	end
	end

	describe "running invites" do
	test "invites are listed" do
	{:ok, invite} = Pleroma.UserInviteToken.create_invite()

	{:ok, invite2} =
	Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})

	# assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invites"
	])

	# end)

	assert_receive {:mix_shell, :info, [message]}
	assert_receive {:mix_shell, :info, [message2]}
	assert_receive {:mix_shell, :info, [message3]}
	assert message =~ "Invites list:"
	assert message2 =~ invite.invite_type
	assert message3 =~ invite2.invite_type
	end
	end

	describe "running revoke_invite" do
	test "invite is revoked" do
	{:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"revoke_invite",
	invite.token
	])
	end)

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Invite for token #{invite.token} was revoked."
	end
	end

	describe "running delete_activities" do
	test "activities are deleted" do
	%{nickname: nickname} = insert(:user)

	assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
	assert_receive {:mix_shell, :info, [message]}
	assert message == "User #{nickname} statuses deleted."
	end

	test "it prints an error message when user is not exist" do
	Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running confirm" do
	test "user is confirmed" do
	%{id: id, nickname: nickname} = insert(:user, is_confirmed: true)

	assert :ok = Mix.Tasks.Pleroma.User.run(["confirm", nickname])
	assert_receive {:mix_shell, :info, [message]}
	assert message == "#{nickname} doesn't need confirmation."

	user = Repo.get(User, id)
	assert user.is_confirmed
	refute user.confirmation_token
	end

	test "user is not confirmed" do
	%{id: id, nickname: nickname} =
	insert(:user, is_confirmed: false, confirmation_token: "some token")

	assert :ok = Mix.Tasks.Pleroma.User.run(["confirm", nickname])
	assert_receive {:mix_shell, :info, [message]}
	assert message == "#{nickname} doesn't need confirmation."

	user = Repo.get(User, id)
	assert user.is_confirmed
	refute user.confirmation_token
	end

	test "it prints an error message when user is not exist" do
	Mix.Tasks.Pleroma.User.run(["confirm", "foo"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running activate" do
	test "user is activated" do
	%{id: id, nickname: nickname} = insert(:user, is_active: true)

	assert :ok = Mix.Tasks.Pleroma.User.run(["activate", nickname])
	assert_receive {:mix_shell, :info, [message]}
	assert message == "User #{nickname} already activated"

	user = Repo.get(User, id)
	assert user.is_active
	end

	test "user is not activated" do
	%{id: id, nickname: nickname} = insert(:user, is_active: false)

	assert :ok = Mix.Tasks.Pleroma.User.run(["activate", nickname])
	assert_receive {:mix_shell, :info, [message]}
	assert message == "Successfully activated #{nickname}"

	user = Repo.get(User, id)
	assert user.is_active
	end

	test "no user to activate" do
	Mix.Tasks.Pleroma.User.run(["activate", "foo"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "search" do
	test "it returns users matching" do
	user = insert(:user)
	moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
	moot = insert(:user, nickname: "moot")
	kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")

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

	assert [moon.id, kawen.id] == User.Search.search("moon") \|> Enum.map(& &1.id)

	res = User.search("moo") \|> Enum.map(& &1.id)
	assert Enum.sort([moon.id, moot.id, kawen.id]) == Enum.sort(res)

	assert [kawen.id, moon.id] == User.Search.search("expert fediverse") \|> Enum.map(& &1.id)

	assert [moon.id, kawen.id] ==
	User.Search.search("expert fediverse", for_user: user) \|> Enum.map(& &1.id)
	end
	end

	describe "signing out" do
	test "it deletes all user's tokens and authorizations" do
	user = insert(:user)
	insert(:oauth_token, user: user)
	insert(:oauth_authorization, user: user)

	assert Repo.get_by(Token, user_id: user.id)
	assert Repo.get_by(Authorization, user_id: user.id)

	:ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])

	refute Repo.get_by(Token, user_id: user.id)
	refute Repo.get_by(Authorization, user_id: user.id)
	end

	test "it prints an error message when user is not exist" do
	Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "tagging" do
	test "it add tags to a user" do
	user = insert(:user)

	:ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])

	user = User.get_cached_by_nickname(user.nickname)
	assert "pleroma" in user.tags
	end

	test "it prints an error message when user is not exist" do
	Mix.Tasks.Pleroma.User.run(["tag", "foo"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "Could not change user tags"
	end
	end

	describe "untagging" do
	test "it deletes tags from a user" do
	user = insert(:user, tags: ["pleroma"])
	assert "pleroma" in user.tags

	:ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])

	user = User.get_cached_by_nickname(user.nickname)
	assert Enum.empty?(user.tags)
	end

	test "it prints an error message when user is not exist" do
	Mix.Tasks.Pleroma.User.run(["untag", "foo"])

	assert_receive {:mix_shell, :error, [message]}
	assert message =~ "Could not change user tags"
	end
	end

	describe "bulk confirm and unconfirm" do
	test "confirm all" do
	user1 = insert(:user, is_confirmed: false)
	user2 = insert(:user, is_confirmed: false)

	refute user1.is_confirmed
	refute user2.is_confirmed

	Mix.Tasks.Pleroma.User.run(["confirm_all"])

	user1 = User.get_cached_by_nickname(user1.nickname)
	user2 = User.get_cached_by_nickname(user2.nickname)

	assert user1.is_confirmed
	assert user2.is_confirmed
	end

	test "unconfirm all" do
	user1 = insert(:user, is_confirmed: true)
	user2 = insert(:user, is_confirmed: true)
	admin = insert(:user, is_admin: true, is_confirmed: true)
	mod = insert(:user, is_moderator: true, is_confirmed: true)

	assert user1.is_confirmed
	assert user2.is_confirmed

	Mix.Tasks.Pleroma.User.run(["unconfirm_all"])

	user1 = User.get_cached_by_nickname(user1.nickname)
	user2 = User.get_cached_by_nickname(user2.nickname)
	admin = User.get_cached_by_nickname(admin.nickname)
	mod = User.get_cached_by_nickname(mod.nickname)

	refute user1.is_confirmed
	refute user2.is_confirmed
	assert admin.is_confirmed
	assert mod.is_confirmed
	end
	end
	end
	diff --git a/test/pleroma/activity/ir/topics_test.exs b/test/pleroma/activity/ir/topics_test.exs
	index 13cfc9d77..2aa5977c8 100644
	--- a/test/pleroma/activity/ir/topics_test.exs
	+++ b/test/pleroma/activity/ir/topics_test.exs
	@@ -1,243 +1,244 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity.Ir.TopicsTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Object

	require Pleroma.Constants

	import Mock

	describe "poll answer" do
	test "produce no topics" do
	activity = %Activity{object: %Object{data: %{"type" => "Answer"}}}

	assert [] == Topics.get_activity_topics(activity)
	end
	end

	describe "non poll answer" do
	test "always add user and list topics" do
	activity = %Activity{object: %Object{data: %{"type" => "FooBar"}}}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "user")
	assert Enum.member?(topics, "list")
	end
	end

	describe "public visibility" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"type" => "Note"}},
	data: %{"to" => [Pleroma.Constants.as_public()], "type" => "Create"}
	}

	{:ok, activity: activity}
	end

	test "produces public topic", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public")
	end

	test "local action produces public:local topic", %{activity: activity} do
	activity = %{activity \| local: true}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:local")
	end

	test "non-local action does not produce public:local topic", %{activity: activity} do
	activity = %{activity \| local: false}
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:local")
	end
	end

	describe "public visibility create events" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => []}},
	data: %{"type" => "Create", "to" => [Pleroma.Constants.as_public()]}
	}

	{:ok, activity: activity}
	end

	test "with no attachments doesn't produce public:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:media")
	refute Enum.member?(topics, "public:local:media")
	end

	test "converts tags to hash tags", %{activity: activity} do
	with_mock(Object, [:passthrough], hashtags: fn _ -> ["foo", "bar"] end) do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "hashtag:foo")
	assert Enum.member?(topics, "hashtag:bar")
	end
	end

	test "only converts strings to hash tags", %{
	activity: %{object: %{data: data} = object} = activity
	} do
	tagged_data = Map.put(data, "tag", [2])
	activity = %{activity \| object: %{object \| data: tagged_data}}

	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "hashtag:2")
	end

	test "non-local action produces public:remote topic", %{activity: activity} do
	activity = %{activity \| local: false, actor: "https://lain.com/users/lain"}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:remote:lain.com")
	end

	test "local action doesn't produce public:remote topic", %{activity: activity} do
	activity = %{activity \| local: true, actor: "https://lain.com/users/lain"}
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:remote:lain.com")
	end
	end

	describe "public visibility Announces" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => []}},
	data: %{"type" => "Announce", "to" => [Pleroma.Constants.as_public()]}
	}

	{:ok, activity: activity}
	end

	test "does not generate public topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	refute "public" in topics
	refute "public:remote" in topics
	refute "public:local" in topics
	end
	end

	describe "local-public visibility create events" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => []}},
	data: %{"type" => "Create", "to" => [Pleroma.Web.ActivityPub.Utils.as_local_public()]}
	}

	{:ok, activity: activity}
	end

	test "doesn't produce public topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public")
	end

	test "produces public:local topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:local")
	end

	test "with no attachments doesn't produce public:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:media")
	refute Enum.member?(topics, "public:local:media")
	end
	end

	describe "public visibility create events with attachments" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => ["foo"]}},
	data: %{"type" => "Create", "to" => [Pleroma.Constants.as_public()]}
	}

	{:ok, activity: activity}
	end

	test "produce public:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:media")
	end

	test "local produces public:local:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:local:media")
	end

	test "non-local doesn't produce public:local:media topics", %{activity: activity} do
	activity = %{activity \| local: false}

	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:local:media")
	end

	test "non-local action produces public:remote:media topic", %{activity: activity} do
	activity = %{activity \| local: false, actor: "https://lain.com/users/lain"}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:remote:media:lain.com")
	end
	end

	describe "local-public visibility create events with attachments" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => ["foo"]}},
	data: %{"type" => "Create", "to" => [Pleroma.Web.ActivityPub.Utils.as_local_public()]}
	}

	{:ok, activity: activity}
	end

	test "do not produce public:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:media")
	end

	test "produces public:local:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:local:media")
	end
	end

	describe "non-public visibility" do
	test "produces direct topic" do
	activity = %Activity{
	object: %Object{data: %{"type" => "Note"}},
	data: %{"to" => [], "type" => "Create"}
	}

	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "direct")
	refute Enum.member?(topics, "public")
	refute Enum.member?(topics, "public:local")
	refute Enum.member?(topics, "public:media")
	refute Enum.member?(topics, "public:local:media")
	end
	end
	end
	diff --git a/test/pleroma/akkoma/translators/argos_translate_test.exs b/test/pleroma/akkoma/translators/argos_translate_test.exs
	index 977df1693..1afb77021 100644
	--- a/test/pleroma/akkoma/translators/argos_translate_test.exs
	+++ b/test/pleroma/akkoma/translators/argos_translate_test.exs
	@@ -1,93 +1,94 @@
	defmodule Pleroma.Akkoma.Translators.ArgosTranslateTest do
	alias Pleroma.Akkoma.Translators.ArgosTranslate

	import Mock

	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	setup do
	clear_config([:argos_translate, :command_argos_translate], "argos-translate_test")
	clear_config([:argos_translate, :command_argospm], "argospm_test")
	end

	test "it lists available languages" do
	languages =
	with_mock System, [:passthrough],
	cmd: fn "argospm_test", ["list"], _ ->
	{"translate-nl_en\ntranslate-en_nl\ntranslate-ja_en\n", 0}
	end do
	ArgosTranslate.languages()
	end

	assert {:ok, source_langs, dest_langs} = languages

	assert [%{code: "en", name: "en"}, %{code: "ja", name: "ja"}, %{code: "nl", name: "nl"}] =
	source_langs \|> Enum.sort()

	assert [%{code: "en", name: "en"}, %{code: "nl", name: "nl"}] = dest_langs \|> Enum.sort()
	end

	test "it translates from the to language when no language is set and returns the text unchanged" do
	assert {:ok, "nl", "blabla"} = ArgosTranslate.translate("blabla", nil, "nl")
	end

	test "it translates from the provided language if provided" do
	translation_response =
	with_mock System, [:passthrough],
	cmd: fn "argos-translate_test", ["--from-lang", "nl", "--to-lang", "en", "blabla"], _ ->
	{"yadayada", 0}
	end do
	ArgosTranslate.translate("blabla", "nl", "en")
	end

	assert {:ok, "nl", "yadayada"} = translation_response
	end

	test "it returns a proper error when the executable can't be found" do
	non_existing_command = "sfqsfgqsefd"
	clear_config([:argos_translate, :command_argos_translate], non_existing_command)
	clear_config([:argos_translate, :command_argospm], non_existing_command)

	assert nil == System.find_executable(non_existing_command)

	assert {:error, "ArgosTranslate failed to fetch languages" <> _} = ArgosTranslate.languages()

	assert {:error, "ArgosTranslate failed to translate" <> _} =
	ArgosTranslate.translate("blabla", "nl", "en")
	end

	test "it can strip html" do
	content =
	~s[<p>What's up my fellow fedizens?</p><p>So anyway</p><ul><li><a class="hashtag" data-tag="cofe" href="https://suya.space/tag/cofe">#cofe</a></li><li><a class="hashtag" data-tag="suya" href="https://cofe.space/tag/suya">#Suya</a></li></ul><p>ammiright!<br/>:ablobfoxhyper:</p>]

	stripped_content =
	"\nWhat's up my fellow fedizens?\n\nSo anyway\n\n#cofe\n#Suya\nammiright!\n:ablobfoxhyper:\n"

	expected_response_strip_html =
	"<br/>What's up my fellow fedizens?<br/><br/>So anyway<br/><br/>#cofe<br/>#Suya<br/>ammiright!<br/>:ablobfoxhyper:<br/>"

	response_strip_html =
	with_mock System, [:passthrough],
	cmd: fn "argos-translate_test",
	["--from-lang", _, "--to-lang", _, ^stripped_content],
	_ ->
	{stripped_content, 0}
	end do
	ArgosTranslate.translate(content, "nl", "en")
	end

	clear_config([:argos_translate, :strip_html], false)

	response_no_strip_html =
	with_mock System, [:passthrough],
	cmd: fn "argos-translate_test", ["--from-lang", _, "--to-lang", _, string], _ ->
	{string, 0}
	end do
	ArgosTranslate.translate(content, "nl", "en")
	end

	assert {:ok, "nl", content} == response_no_strip_html

	assert {:ok, "nl", expected_response_strip_html} == response_strip_html
	end
	end
	diff --git a/test/pleroma/application_requirements_test.exs b/test/pleroma/application_requirements_test.exs
	index 297acb63d..586af4d8e 100644
	--- a/test/pleroma/application_requirements_test.exs
	+++ b/test/pleroma/application_requirements_test.exs
	@@ -1,166 +1,167 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ApplicationRequirementsTest do
	use Pleroma.DataCase, async: false

	import ExUnit.CaptureLog
	+ @moduletag :mocked
	import Mock

	alias Pleroma.ApplicationRequirements
	alias Pleroma.Repo

	describe "check_repo_pool_size!/1" do
	test "raises if the pool size is unexpected" do
	clear_config([Pleroma.Repo, :pool_size], 11)
	clear_config([:dangerzone, :override_repo_pool_size], false)

	assert_raise Pleroma.ApplicationRequirements.VerifyError,
	"Repo.pool_size different than recommended value.",
	fn ->
	capture_log(&Pleroma.ApplicationRequirements.verify!/0)
	end
	end

	test "doesn't raise if the pool size is unexpected but the respective flag is set" do
	clear_config([Pleroma.Repo, :pool_size], 11)
	clear_config([:dangerzone, :override_repo_pool_size], true)

	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end
	end

	describe "check_welcome_message_config!/1" do
	setup do: clear_config([:welcome])
	setup do: clear_config([Pleroma.Emails.Mailer])

	test "warns if welcome email enabled but mail disabled" do
	clear_config([:welcome, :email, :enabled], true)
	clear_config([Pleroma.Emails.Mailer, :enabled], false)

	assert capture_log(fn ->
	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end) =~ "Welcome emails will NOT be sent"
	end
	end

	describe "check_confirmation_accounts!" do
	setup_with_mocks([
	{Pleroma.ApplicationRequirements, [:passthrough],
	[
	check_migrations_applied!: fn _ -> :ok end
	]}
	]) do
	:ok
	end

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

	test "warns if account confirmation is required but mailer isn't enabled" do
	clear_config([:instance, :account_activation_required], true)
	clear_config([Pleroma.Emails.Mailer, :enabled], false)

	assert capture_log(fn ->
	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end) =~ "Users will NOT be able to confirm their accounts"
	end

	test "doesn't do anything if account confirmation is disabled" do
	clear_config([:instance, :account_activation_required], false)
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end

	test "doesn't do anything if account confirmation is required and mailer is enabled" do
	clear_config([:instance, :account_activation_required], true)
	clear_config([Pleroma.Emails.Mailer, :enabled], true)
	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end
	end

	describe "check_rum!" do
	setup_with_mocks([
	{Pleroma.ApplicationRequirements, [:passthrough],
	[check_migrations_applied!: fn _ -> :ok end]}
	]) do
	:ok
	end

	setup do: clear_config([:database, :rum_enabled])

	test "raises if rum is enabled and detects unapplied rum migrations" do
	clear_config([:database, :rum_enabled], true)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
	assert_raise ApplicationRequirements.VerifyError,
	"Unapplied RUM Migrations detected",
	fn ->
	capture_log(&ApplicationRequirements.verify!/0)
	end
	end
	end

	test "raises if rum is disabled and detects rum migrations" do
	clear_config([:database, :rum_enabled], false)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
	assert_raise ApplicationRequirements.VerifyError,
	"RUM Migrations detected",
	fn ->
	capture_log(&ApplicationRequirements.verify!/0)
	end
	end
	end

	test "doesn't do anything if rum enabled and applied migrations" do
	clear_config([:database, :rum_enabled], true)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
	assert ApplicationRequirements.verify!() == :ok
	end
	end

	test "doesn't do anything if rum disabled" do
	clear_config([:database, :rum_enabled], false)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
	assert ApplicationRequirements.verify!() == :ok
	end
	end
	end

	describe "check_migrations_applied!" do
	setup_with_mocks([
	{Ecto.Migrator, [],
	[
	with_repo: fn repo, fun -> passthrough([repo, fun]) end,
	migrations: fn Repo ->
	[
	{:up, 20_191_128_153_944, "fix_missing_following_count"},
	{:up, 20_191_203_043_610, "create_report_notes"},
	{:down, 20_191_220_174_645, "add_scopes_to_pleroma_feo_auth_records"}
	]
	end
	]}
	]) do
	:ok
	end

	setup do: clear_config([:i_am_aware_this_may_cause_data_loss, :disable_migration_check])

	test "raises if it detects unapplied migrations" do
	assert_raise ApplicationRequirements.VerifyError,
	"Unapplied Migrations detected",
	fn ->
	capture_log(&ApplicationRequirements.verify!/0)
	end
	end

	test "doesn't do anything if disabled" do
	clear_config([:i_am_aware_this_may_cause_data_loss, :disable_migration_check], true)

	assert :ok == ApplicationRequirements.verify!()
	end
	end
	end
	diff --git a/test/pleroma/config_db_test.exs b/test/pleroma/config_db_test.exs
	index ace347f65..43bb38afe 100644
	--- a/test/pleroma/config_db_test.exs
	+++ b/test/pleroma/config_db_test.exs
	@@ -1,528 +1,528 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigDBTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.ConfigDB

	test "get_by_params/1" do
	config = insert(:config)
	insert(:config)

	assert config == ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	describe "update_or_create/1" do
	test "common" do
	config = insert(:config)
	key2 = :another_key

	params = [
	%{group: :pleroma, key: key2, value: "another_value"},
	%{group: :pleroma, key: config.key, value: [a: 1, b: 2, c: "new_value"]}
	]

	assert Repo.all(ConfigDB) \|> length() == 1

	Enum.each(params, &ConfigDB.update_or_create(&1))

	assert Repo.all(ConfigDB) \|> length() == 2

	config1 = ConfigDB.get_by_params(%{group: config.group, key: config.key})
	config2 = ConfigDB.get_by_params(%{group: :pleroma, key: key2})

	assert config1.value == [a: 1, b: 2, c: "new_value"]
	assert config2.value == "another_value"
	end

	test "partial update" do
	config = insert(:config, value: [key1: "val1", key2: :val2])

	{:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert config.value == updated.value
	assert updated.value[:key1] == :val1
	assert updated.value[:key2] == :val2
	assert updated.value[:key3] == :val3
	end

	test "deep merge" do
	config = insert(:config, value: [key1: "val1", key2: [k1: :v1, k2: "v2"]])

	{:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key2: [k2: :v2, k3: :v3], key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert config.value == updated.value
	assert updated.value[:key1] == :val1
	assert updated.value[:key2] == [k1: :v1, k2: :v2, k3: :v3]
	assert updated.value[:key3] == :val3
	end

	test "only full update for some keys" do
	config1 = insert(:config, key: :ecto_repos, value: [repo: Pleroma.Repo])

	config2 = insert(:config, group: :cors_plug, key: :max_age, value: 18)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [another_repo: [Pleroma.Repo]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: 777
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	assert updated1.value == [another_repo: [Pleroma.Repo]]
	assert updated2.value == 777
	end

	test "full update if value is not keyword" do
	config =
	insert(:config,
	group: ":tesla",
	key: ":adapter",
	value: Tesla.Adapter.Hackney
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: Tesla.Adapter.Httpc
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert updated.value == Tesla.Adapter.Httpc
	end

	test "only full update for some subkeys" do
	config1 =
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	config2 =
	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [groups: [c: 3, d: 4], key: [b: 2]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: [mascots: [c: 3, d: 4], key: [b: 2]]
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	assert updated1.value == [groups: [c: 3, d: 4], key: [a: 1, b: 2]]
	assert updated2.value == [mascots: [c: 3, d: 4], key: [a: 1, b: 2]]
	end
	end

	describe "delete/1" do
	test "error on deleting non existing setting" do
	{:error, error} = ConfigDB.delete(%{group: ":pleroma", key: ":key"})
	assert error =~ "Config with params %{group: \":pleroma\", key: \":key\"} not found"
	end

	test "full delete" do
	config = insert(:config)
	{:ok, deleted} = ConfigDB.delete(%{group: config.group, key: config.key})
	assert Ecto.get_meta(deleted, :state) == :deleted
	refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	test "partial subkeys delete" do
	config = insert(:config, value: [groups: [a: 1, b: 2], key: [a: 1]])

	{:ok, deleted} =
	ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})

	assert Ecto.get_meta(deleted, :state) == :loaded

	assert deleted.value == [key: [a: 1]]

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert updated.value == deleted.value
	end

	test "full delete if remaining value after subkeys deletion is empty list" do
	config = insert(:config, value: [groups: [a: 1, b: 2]])

	{:ok, deleted} =
	ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})

	assert Ecto.get_meta(deleted, :state) == :deleted

	refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end
	end

	describe "to_elixir_types/1" do
	test "string" do
	assert ConfigDB.to_elixir_types("value as string") == "value as string"
	end

	test "boolean" do
	assert ConfigDB.to_elixir_types(false) == false
	end

	test "nil" do
	assert ConfigDB.to_elixir_types(nil) == nil
	end

	test "integer" do
	assert ConfigDB.to_elixir_types(150) == 150
	end

	test "atom" do
	assert ConfigDB.to_elixir_types(":atom") == :atom
	end

	test "ssl options" do
	assert ConfigDB.to_elixir_types([":tlsv1", ":tlsv1.1", ":tlsv1.2"]) == [
	:tlsv1,
	:"tlsv1.1",
	:"tlsv1.2"
	]
	end

	test "pleroma module" do
	assert ConfigDB.to_elixir_types("Pleroma.Bookmark") == Pleroma.Bookmark
	end

	test "removed module" do
	assert ConfigDB.to_elixir_types("Pleroma.Nowhere") == :invalid_atom
	end

	test "pleroma string" do
	assert ConfigDB.to_elixir_types("Pleroma") == "Pleroma"
	end

	test "phoenix module" do
	assert ConfigDB.to_elixir_types("Phoenix.Socket.V1.JSONSerializer") ==
	Phoenix.Socket.V1.JSONSerializer
	end

	test "tesla module" do
	assert ConfigDB.to_elixir_types("Tesla.Adapter.Hackney") == Tesla.Adapter.Hackney
	end

	test "ExSyslogger module" do
	assert ConfigDB.to_elixir_types("ExSyslogger") == ExSyslogger
	end

	test "Quack.Logger module" do
	assert ConfigDB.to_elixir_types("Quack.Logger") == Quack.Logger
	end

	test "Swoosh.Adapters modules" do
	assert ConfigDB.to_elixir_types("Swoosh.Adapters.SMTP") == Swoosh.Adapters.SMTP
	assert ConfigDB.to_elixir_types("Swoosh.Adapters.AmazonSES") == Swoosh.Adapters.AmazonSES
	end

	test "sigil" do
	assert ConfigDB.to_elixir_types("~r[comp[lL][aA][iI][nN]er]") == ~r/comp[lL][aA][iI][nN]er/
	end

	test "link sigil" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/") == ~r/https:\/\/example.com/
	end

	test "link sigil with um modifiers" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/um") ==
	~r/https:\/\/example.com/um
	end

	test "link sigil with i modifier" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/i") == ~r/https:\/\/example.com/i
	end

	test "link sigil with s modifier" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/s") == ~r/https:\/\/example.com/s
	end

	test "raise if valid delimiter not found" do
	assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
	ConfigDB.to_elixir_types("~r/https://[]{}<>\"'()\|example.com/s")
	end
	end

	test "2 child tuple" do
	assert ConfigDB.to_elixir_types(%{"tuple" => ["v1", ":v2"]}) == {"v1", :v2}
	end

	test "proxy tuple with localhost" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
	}) == {:proxy_url, {:socks5, :localhost, 1234}}
	end

	test "proxy tuple with domain" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
	}) == {:proxy_url, {:socks5, ~c"domain.com", 1234}}
	end

	test "proxy tuple with ip" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
	}) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
	end

	test "tuple with n childs" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [
	"v1",
	":v2",
	"Pleroma.Bookmark",
	150,
	false,
	"Phoenix.Socket.V1.JSONSerializer"
	]
	}) == {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	end

	test "map with string key" do
	assert ConfigDB.to_elixir_types(%{"key" => "value"}) == %{"key" => "value"}
	end

	test "map with atom key" do
	assert ConfigDB.to_elixir_types(%{":key" => "value"}) == %{key: "value"}
	end

	test "list of strings" do
	assert ConfigDB.to_elixir_types(["v1", "v2", "v3"]) == ["v1", "v2", "v3"]
	end

	test "list of modules" do
	assert ConfigDB.to_elixir_types(["Pleroma.Repo", "Pleroma.Activity"]) == [
	Pleroma.Repo,
	Pleroma.Activity
	]
	end

	test "list of atoms" do
	assert ConfigDB.to_elixir_types([":v1", ":v2", ":v3"]) == [:v1, :v2, :v3]
	end

	test "list of mixed values" do
	assert ConfigDB.to_elixir_types([
	"v1",
	":v2",
	"Pleroma.Repo",
	"Phoenix.Socket.V1.JSONSerializer",
	15,
	false
	]) == [
	"v1",
	:v2,
	Pleroma.Repo,
	Phoenix.Socket.V1.JSONSerializer,
	15,
	false
	]
	end

	test "simple keyword" do
	assert ConfigDB.to_elixir_types([%{"tuple" => [":key", "value"]}]) == [key: "value"]
	end

	test "keyword" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":types", "Pleroma.PostgresTypes"]},
	%{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
	%{"tuple" => [":migration_lock", nil]},
	%{"tuple" => [":key1", 150]},
	%{"tuple" => [":key2", "string"]}
	]) == [
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil,
	key1: 150,
	key2: "string"
	]
	end

	test "trandformed keyword" do
	assert ConfigDB.to_elixir_types(a: 1, b: 2, c: "string") == [a: 1, b: 2, c: "string"]
	end

	test "complex keyword with nested mixed childs" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
	%{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	%{"tuple" => [":link_name", true]},
	%{"tuple" => [":proxy_remote", false]},
	%{"tuple" => [":common_map", %{":key" => "value"}]},
	%{
	"tuple" => [
	":proxy_opts",
	[
	%{"tuple" => [":redirect_on_failure", false]},
	%{"tuple" => [":max_body_length", 1_048_576]},
	%{
	"tuple" => [
	":http",
	[
	%{"tuple" => [":follow_redirect", true]},
	%{"tuple" => [":pool", ":upload"]}
	]
	]
	}
	]
	]
	}
	]) == [
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_remote: false,
	common_map: %{key: "value"},
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	]
	]
	end

	test "common keyword" do
	assert ConfigDB.to_elixir_types([
	- %{"tuple" => [":level", ":warn"]},
	+ %{"tuple" => [":level", ":warning"]},
	%{"tuple" => [":meta", [":all"]]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":val", nil]},
	%{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
	]) == [
	- level: :warn,
	+ level: :warning,
	meta: [:all],
	path: "",
	val: nil,
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	]
	end

	test "complex keyword with sigil" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":federated_timeline_removal", []]},
	%{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
	%{"tuple" => [":replace", []]}
	]) == [
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	]
	end

	test "complex keyword with tuples with more than 2 values" do
	assert ConfigDB.to_elixir_types([
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key1",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]) == [
	http: [
	key1: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	]
	]
	end
	end
	end
	diff --git a/test/pleroma/notification_test.exs b/test/pleroma/notification_test.exs
	index 69ff27466..c3ba399a6 100644
	--- a/test/pleroma/notification_test.exs
	+++ b/test/pleroma/notification_test.exs
	@@ -1,1285 +1,1286 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	import Pleroma.Factory
	import Mock

	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	describe "create_notifications" do
	test "never returns nil" do
	user = insert(:user)
	other_user = insert(:user, %{invisible: true})

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	refute {:ok, [nil]} == Notification.create_notifications(activity)
	end

	test "creates a notification for a report" do
	reporting_user = insert(:user)
	reported_user = insert(:user)
	{:ok, moderator_user} = insert(:user) \|> User.admin_api_update(%{is_moderator: true})

	{:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})

	{:ok, [notification]} = Notification.create_notifications(activity)

	assert notification.user_id == moderator_user.id
	assert notification.type == "pleroma:report"
	end

	test "suppresses notification to reporter if reporter is an admin" do
	reporting_admin = insert(:user, is_admin: true)
	reported_user = insert(:user)
	other_admin = insert(:user, is_admin: true)

	{:ok, activity} = CommonAPI.report(reporting_admin, %{account_id: reported_user.id})

	{:ok, [notification]} = Notification.create_notifications(activity)

	refute notification.user_id == reporting_admin.id
	assert notification.user_id == other_admin.id
	assert notification.type == "pleroma:report"
	end

	test "creates a notification for an emoji reaction" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	{:ok, [notification]} = Notification.create_notifications(activity)

	assert notification.user_id == user.id
	assert notification.type == "pleroma:emoji_reaction"
	end

	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, [notification, other_notification]} = Notification.create_notifications(activity)

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert notification.type == "mention"
	assert other_notification.activity_id == activity.id

	assert [%Pleroma.Marker{unread_count: 2}] =
	Pleroma.Marker.get_markers(other_user, ["notifications"])
	end

	test "it creates a notification for subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification.user_id == subscriber.id
	end

	test "does not create a notification for subscribed users if status is a reply" do
	user = insert(:user)
	other_user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, other_user)

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

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	status: "test reply",
	in_reply_to_status_id: activity.id
	})

	user_notifications = Notification.for_user(user)
	assert length(user_notifications) == 1

	subscriber_notifications = Notification.for_user(subscriber)
	assert Enum.empty?(subscriber_notifications)
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

	{:ok, _edit_activity} =
	CommonAPI.update(user, activity_one, %{
	status: "hey @#{other_user.nickname}! mew mew"
	})

	assert [%{type: "reblog"}] = Notification.for_user(user)
	assert [%{type: "update"}] = Notification.for_user(repeated_user)
	assert [%{type: "mention"}] = Notification.for_user(other_user)
	end
	end

	test "create_poll_notifications/1" do
	[user1, user2, user3, _, _] = insert_list(5, :user)
	question = insert(:question, user: user1)
	activity = insert(:question_activity, question: question)

	{:ok, _, _} = CommonAPI.vote(user2, question, [0])
	{:ok, _, _} = CommonAPI.vote(user3, question, [1])

	{:ok, notifications} = Notification.create_poll_notifications(activity)

	assert [user2.id, user3.id, user1.id] == Enum.map(notifications, & &1.user_id)
	end

	describe "CommonApi.post/2 notification-related functionality" do
	test_with_mock "creates but does NOT send notification to blocker user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	blocker = insert(:user)
	{:ok, _user_relationship} = User.block(blocker, user)

	{:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{blocker.nickname}!"})

	blocker_id = blocker.id
	assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification)
	refute called(Push.send(:_))
	end

	test_with_mock "creates but does NOT send notification to notification-muter user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	muter = insert(:user)
	{:ok, _user_relationships} = User.mute(muter, user)

	{:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{muter.nickname}!"})

	muter_id = muter.id
	assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification)
	refute called(Push.send(:_))
	end

	test_with_mock "creates but does NOT send notification to thread-muter user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	thread_muter = insert(:user)

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

	{:ok, _} = CommonAPI.add_mute(thread_muter, activity)

	{:ok, _same_context_activity} =
	CommonAPI.post(user, %{
	status: "hey-hey-hey @#{thread_muter.nickname}!",
	in_reply_to_status_id: activity.id
	})

	[pre_mute_notification, post_mute_notification] =
	Repo.all(from(n in Notification, where: n.user_id == ^thread_muter.id, order_by: n.id))

	pre_mute_notification_id = pre_mute_notification.id
	post_mute_notification_id = post_mute_notification.id

	assert called(
	Push.send(
	:meck.is(fn
	%Notification{id: ^pre_mute_notification_id} -> true
	_ -> false
	end)
	)
	)

	refute called(
	Push.send(
	:meck.is(fn
	%Notification{id: ^post_mute_notification_id} -> true
	_ -> false
	end)
	)
	)
	end
	end

	describe "create_notification" do
	@tag needs_streamer: true
	test "it creates a notification for user and send to the 'user' and the 'user:notification' stream" do
	%{user: user, token: oauth_token} = oauth_access(["read"])

	task =
	Task.async(fn ->
	{:ok, _topic} = Streamer.get_topic_and_add_socket("user", user, oauth_token)
	assert_receive {:render_with_user, _, _, _, "user"}, 4_000
	end)

	task_user_notification =
	Task.async(fn ->
	{:ok, _topic} =
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	assert_receive {:render_with_user, _, _, _, "user:notification"}, 4_000
	end)

	activity = insert(:note_activity)

	notify = Notification.create_notification(activity, user)
	assert notify.user_id == user.id
	Task.await(task)
	Task.await(task_user_notification)
	end

	test "it creates a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, _user_relationship} = User.block(user, author)

	assert Notification.create_notification(activity, user)
	end

	test "it creates a notification for the user if the user mutes the activity author" do
	muter = insert(:user)
	muted = insert(:user)
	{:ok, _} = User.mute(muter, muted)
	muter = Repo.get(User, muter.id)
	{:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})

	notification = Notification.create_notification(activity, muter)

	assert notification.id
	assert notification.seen
	end

	test "notification created if user is muted without notifications" do
	muter = insert(:user)
	muted = insert(:user)

	{:ok, _user_relationships} = User.mute(muter, muted, %{notifications: false})

	{:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})

	assert Notification.create_notification(activity, muter)
	end

	test "it creates a notification for an activity from a muted thread" do
	muter = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(muter, %{status: "hey"})
	CommonAPI.add_mute(muter, activity)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Hi @#{muter.nickname}",
	in_reply_to_status_id: activity.id
	})

	notification = Notification.create_notification(activity, muter)

	assert notification.id
	assert notification.seen
	end

	test "it disables notifications from strangers" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from non-followees" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(follower, followed)
	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it allows notifications from followees" do
	poster = insert(:user)

	receiver =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(receiver, poster)
	{:ok, activity} = CommonAPI.post(poster, %{status: "hey @#{receiver.nickname}"})
	assert Notification.create_notification(activity, receiver)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	refute Notification.create_notification(activity, author)
	end

	test "it doesn't create duplicate notifications for follow+subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(subscriber, user)
	User.subscribe(subscriber, user)
	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [_notif]} = Notification.create_notifications(status)
	end

	test "it doesn't create subscription notifications if the recipient cannot see the status" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it disables notifications from people who are invisible" do
	author = insert(:user, invisible: true)
	user = insert(:user)

	{:ok, status} = CommonAPI.post(author, %{status: "hey @#{user.nickname}"})
	refute Notification.create_notification(status, user)
	end

	test "it doesn't create notifications if content matches with an irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: true)

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

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it creates notifications if content matches with a not irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: false)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification
	refute notification.seen
	end

	test "it creates notifications when someone likes user's status with a filtered word" do
	user = insert(:user)
	other_user = insert(:user)
	insert(:filter, user: user, phrase: "tesla", hide: true)

	{:ok, activity_one} = CommonAPI.post(user, %{status: "wow tesla"})
	{:ok, activity_two} = CommonAPI.favorite(other_user, activity_one.id)

	{:ok, [notification]} = Notification.create_notifications(activity_two)

	assert notification
	refute notification.seen
	end
	end

	describe "follow / follow_request notifications" do
	test "it creates `follow` notification for approved Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end

	test "it creates `follow_request` notification for pending Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: true)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	render_opts = %{notification: notification, for: followed_user}
	assert %{type: "follow_request"} = NotificationView.render("show.json", render_opts)

	# After request is accepted, the same notification is rendered with type "follow":
	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	notification =
	Repo.get(Notification, notification.id)
	\|> Repo.preload(:activity)

	assert %{type: "follow"} =
	NotificationView.render("show.json",
	notification: notification,
	for: followed_user
	)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [_notification] = Notification.for_user(followed_user)

	CommonAPI.unfollow(user, followed_user)
	{:ok, _, _, _activity_dupe} = CommonAPI.follow(user, followed_user)

	assert Enum.count(Notification.for_user(followed_user)) == 1
	end

	test "dismisses the notification on follow request rejection" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	{:ok, _, _, _follow_activity} = CommonAPI.follow(follower, user)
	assert [_notification] = Notification.for_user(user)
	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
	assert [] = Notification.for_user(user)
	end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.get(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.dismiss(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "destroy_multiple_from_types/2" do
	test "clears all notifications of a certain type for a given user" do
	report_activity = insert(:report_activity)
	user1 = insert(:user, is_moderator: true, is_admin: true)
	user2 = insert(:user, is_moderator: true, is_admin: true)
	{:ok, _} = Notification.create_notifications(report_activity)

	{:ok, _} =
	CommonAPI.post(user2, %{
	status: "hey @#{user1.nickname} !"
	})

	Notification.destroy_multiple_from_types(user1, ["pleroma:report"])

	assert [%Pleroma.Notification{type: "mention"}] = Notification.for_user(user1)
	assert [%Pleroma.Notification{type: "pleroma:report"}] = Notification.for_user(user2)
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = Notification.for_user(other_user)

	assert n2.id > n1.id

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey yet again @#{other_user.nickname}!"
	})

	[_, read_notification] = Notification.set_read_up_to(other_user, n2.id)

	assert read_notification.activity.object

	[n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false

	assert %Pleroma.Marker{} =
	m =
	Pleroma.Repo.get_by(
	Pleroma.Marker,
	user_id: other_user.id,
	timeline: "notifications"
	)

	assert m.last_read_id == to_string(n2.id)
	end
	end

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

	test "Returns recent notifications" do
	user1 = insert(:user)
	user2 = insert(:user)

	Enum.each(0..10, fn i ->
	{:ok, _activity} =
	CommonAPI.post(user1, %{
	status: "hey ##{i} @#{user2.nickname}!"
	})
	end)

	{old, new} = Enum.split(Notification.for_user(user2), 5)

	Enum.each(old, fn notification ->
	notification
	\|> cast(%{updated_at: days_ago(10)}, [:updated_at])
	\|> Pleroma.Repo.update!()
	end)

	recent_notifications_ids =
	user2
	\|> Notification.for_user_since(
	NaiveDateTime.add(NaiveDateTime.utc_now(), -5 * 86_400, :second)
	)
	\|> Enum.map(& &1.id)

	Enum.each(old, fn %{id: id} ->
	refute id in recent_notifications_ids
	end)

	Enum.each(new, fn %{id: id} ->
	assert id in recent_notifications_ids
	end)
	end
	end

	describe "notification target determination / get_notified_from_activity/2" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

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

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert other_user not in enabled_receivers
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two} = CommonAPI.favorite(third_user, activity_one.id)

	{enabled_receivers, _disabled_receivers} =
	Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it only notifies the post's author in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, like_data, _} = Builder.like(third_user, activity_one.object)

	{:ok, like, _} =
	like_data
	\|> Map.put("to", [other_user.ap_id \| like_data["to"]])
	\|> ActivityPub.persist(local: true)

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(like)

	assert other_user not in enabled_receivers
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two} = CommonAPI.repeat(activity_one.id, third_user)

	{enabled_receivers, _disabled_receivers} =
	Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it returns blocking recipient in disabled recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(other_user, user)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns notification-muting recipient in disabled recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationships} = User.mute(other_user, user)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns thread-muting recipient in disabled recipients list" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, _} = CommonAPI.add_mute(other_user, activity)

	{:ok, same_context_activity} =
	CommonAPI.post(user, %{
	status: "hey-hey-hey @#{other_user.nickname}!",
	in_reply_to_status_id: activity.id
	})

	{enabled_receivers, disabled_receivers} =
	Notification.get_notified_from_activity(same_context_activity)

	assert [other_user] == disabled_receivers
	refute other_user in enabled_receivers
	end

	test "it returns non-following domain-blocking recipient in disabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns following domain-blocking recipient in enabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

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

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [other_user] == enabled_receivers
	assert [] == disabled_receivers
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

	{:ok, edit_activity} =
	CommonAPI.update(user, activity_one, %{
	status: "hey @#{other_user.nickname}! mew mew"
	})

	{enabled_receivers, _disabled_receivers} =
	Notification.get_notified_from_activity(edit_activity)

	assert repeated_user in enabled_receivers
	assert other_user not in enabled_receivers
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.unfavorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.unrepeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, :not_found} = CommonAPI.favorite(other_user, activity.id)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "replying to a deleted post without tagging does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})
	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	status: "test reply",
	in_reply_to_status_id: activity.id
	})

	assert Enum.empty?(Notification.for_user(user))
	end

	test "notifications are deleted if a local user is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})

	refute Enum.empty?(Notification.for_user(other_user))

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

	assert Enum.empty?(Notification.for_user(other_user))
	end

	test "notifications are deleted if a remote user is deleted" do
	remote_user = insert(:user)
	local_user = insert(:user)

	dm_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => remote_user.ap_id,
	"id" => remote_user.ap_id <> "/activities/test",
	"to" => [local_user.ap_id],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => remote_user.ap_id <> "/objects/test",
	"content" => "Hello!",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => local_user.ap_id,
	"name" => "@#{local_user.nickname}"
	}
	],
	"to" => [local_user.ap_id],
	"cc" => [],
	"attributedTo" => remote_user.ap_id
	}
	}

	{:ok, _dm_activity} = Transmogrifier.handle_incoming(dm_message)

	refute Enum.empty?(Notification.for_user(local_user))

	delete_user_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => remote_user.ap_id <> "/activities/delete",
	"actor" => remote_user.ap_id,
	"type" => "Delete",
	"object" => remote_user.ap_id
	}

	remote_user_url = remote_user.ap_id

	Tesla.Mock.mock(fn
	%{method: :get, url: ^remote_user_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	{:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
	ObanHelpers.perform_all()

	assert Enum.empty?(Notification.for_user(local_user))
	end

	test "move activity generates a notification" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	other_follower = insert(:user, %{allow_following_move: false})

	User.follow(follower, old_user)
	User.follow(other_follower, old_user)

	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	ObanHelpers.perform_all()

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(follower)

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(other_follower)
	end
	end

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

	{:ok, %{user: user}}
	end

	test "it returns notifications for muted user without notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted, %{notifications: false})

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

	[notification] = Notification.for_user(user)

	assert notification.activity.object
	assert notification.seen
	end

	test "it doesn't return notifications for muted user with notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

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

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for blocked user", %{user: user} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

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

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for domain-blocked non-followed user", %{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

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

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for muted thread", %{user: user} do
	another_user = insert(:user)

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

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert Notification.for_user(user) == []
	end

	test "it returns notifications from a muted user when with_muted is set", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

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

	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications from a blocked user when with_muted is set", %{
	user: user
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

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

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "when with_muted is set, " <>
	"it doesn't return notifications from a domain-blocked non-followed user",
	%{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

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

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it returns notifications from muted threads when with_muted is set", %{user: user} do
	another_user = insert(:user)

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

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications about mentions with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(another_user, %{status: "@#{user.nickname} got cofe?"})

	assert Enum.empty?(Notification.for_user(user))
	end

	test "it returns notifications about mentions with not hidden filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "test", hide: false)
	another_user = insert(:user)

	{:ok, _} = CommonAPI.post(another_user, %{status: "@#{user.nickname} test"})

	assert length(Notification.for_user(user)) == 1
	end

	test "it returns notifications about favorites with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Give me my cofe!"})
	{:ok, _} = CommonAPI.favorite(another_user, activity.id)

	assert length(Notification.for_user(user)) == 1
	end

	test "it returns notifications when related object is without content and filters are defined",
	%{user: user} do
	followed_user = insert(:user, is_locked: true)

	insert(:filter, user: followed_user, phrase: "test", hide: true)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow_request"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})

	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end
	end
	end
	diff --git a/test/pleroma/object/fetcher_test.exs b/test/pleroma/object/fetcher_test.exs
	index e4d4fe8a3..8cf0bce48 100644
	--- a/test/pleroma/object/fetcher_test.exs
	+++ b/test/pleroma/object/fetcher_test.exs
	@@ -1,646 +1,647 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.FetcherTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher

	import Mock
	import Tesla.Mock

	setup do
	mock(fn
	%{method: :get, url: "https://mastodon.example.org/users/userisgone"} ->
	%Tesla.Env{status: 410}

	%{method: :get, url: "https://mastodon.example.org/users/userisgone404"} ->
	%Tesla.Env{status: 404}

	%{
	method: :get,
	url:
	"https://patch.cx/media/03ca3c8b4ac3ddd08bf0f84be7885f2f88de0f709112131a22d83650819e36c2.json"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/spoofed-object.json")
	}

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

	:ok
	end

	describe "error cases" do
	setup do
	mock(fn
	%{method: :get, url: "https://social.sakamoto.gq/notice/9wTkLEnuq47B25EehM"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/fetch_mocks/9wTkLEnuq47B25EehM.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	%{method: :get, url: "https://social.sakamoto.gq/users/eal"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/fetch_mocks/eal.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	%{method: :get, url: "https://busshi.moe/users/tuxcrafting/statuses/104410921027210069"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/fetch_mocks/104410921027210069.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	%{method: :get, url: "https://busshi.moe/users/tuxcrafting"} ->
	%Tesla.Env{
	status: 500
	}

	%{
	method: :get,
	url: "https://stereophonic.space/objects/02997b83-3ea7-4b63-94af-ef3aa2d4ed17"
	} ->
	%Tesla.Env{
	status: 500
	}
	end)

	:ok
	end

	@tag capture_log: true
	test "it works when fetching the OP actor errors out" do
	# Here we simulate a case where the author of the OP can't be read
	assert {:ok, _} =
	Fetcher.fetch_object_from_id(
	"https://social.sakamoto.gq/notice/9wTkLEnuq47B25EehM"
	)
	end
	end

	describe "max thread distance restriction" do
	@ap_id "http://mastodon.example.org/@admin/99541947525187367"
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	test "it returns thread depth exceeded error if thread depth is exceeded" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	assert {:error, "Max thread distance exceeded."} =
	Fetcher.fetch_object_from_id(@ap_id, depth: 1)
	end

	test "it fetches object if max thread depth is restricted to 0 and depth is not specified" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id)
	end

	test "it fetches object if requested depth does not exceed max thread depth" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 10)

	assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id, depth: 10)
	end
	end

	describe "actor origin containment" do
	test "it rejects objects with a bogus origin" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 1)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 2)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	end
	end

	describe "fetching an object" do
	test "it fetches an object" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert _activity = Activity.get_create_by_object_ap_id(object.data["id"])

	{:ok, object_again} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert [attachment] = object.data["attachment"]
	assert is_list(attachment["url"])

	assert object == object_again
	end

	test "Return MRF reason when fetched status is rejected by one" do
	clear_config([:mrf_keyword, :reject], ["yeah"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	assert {:reject, "[KeywordPolicy] Matches with rejected keyword"} ==
	Fetcher.fetch_object_from_id(
	"http://mastodon.example.org/@admin/99541947525187367"
	)
	end

	test "it does not fetch a spoofed object uploaded on an instance as an attachment" do
	assert {:error, _} =
	Fetcher.fetch_object_from_id(
	"https://patch.cx/media/03ca3c8b4ac3ddd08bf0f84be7885f2f88de0f709112131a22d83650819e36c2.json"
	)
	end

	test "does not fetch anything from a rejected instance" do
	clear_config([:mrf_simple, :reject], [{"evil.example.org", "i said so"}])

	assert {:reject, _} =
	Fetcher.fetch_object_from_id("http://evil.example.org/@admin/99541947525187367")
	end

	test "does not fetch anything if mrf_simple accept is on" do
	clear_config([:mrf_simple, :accept], [{"mastodon.example.org", "i said so"}])
	clear_config([:mrf_simple, :reject], [])

	assert {:reject, _} =
	Fetcher.fetch_object_from_id(
	"http://notlisted.example.org/@admin/99541947525187367"
	)

	assert {:ok, _object} =
	Fetcher.fetch_object_from_id(
	"http://mastodon.example.org/@admin/99541947525187367"
	)
	end

	test "it resets instance reachability on successful fetch" do
	id = "http://mastodon.example.org/@admin/99541947525187367"
	Instances.set_consistently_unreachable(id)
	refute Instances.reachable?(id)

	{:ok, _object} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert Instances.reachable?(id)
	end
	end

	describe "implementation quirks" do
	test "it can fetch plume articles" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
	)

	assert object
	end

	test "it can fetch peertube videos" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	assert object
	end

	test "it can fetch Mobilizon events" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
	)

	assert object
	end

	test "it can fetch wedistribute articles" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("https://wedistribute.org/wp-json/pterotype/v1/object/85810")

	assert object
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	assert {:error, _} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end

	test "handle HTTP 410 Gone response" do
	assert {:error,
	{"Object has been deleted", "https://mastodon.example.org/users/userisgone", 410}} ==
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://mastodon.example.org/users/userisgone"
	)
	end

	test "handle HTTP 404 response" do
	assert {:error,
	{"Object has been deleted", "https://mastodon.example.org/users/userisgone404", 404}} ==
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://mastodon.example.org/users/userisgone404"
	)
	end

	test "it can fetch pleroma polls with attachments" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("https://patch.cx/objects/tesla_mock/poll_attachment")

	assert object
	end
	end

	describe "pruning" do
	test "it can refetch pruned objects" do
	object_id = "http://mastodon.example.org/@admin/99541947525187367"

	{:ok, object} = Fetcher.fetch_object_from_id(object_id)

	assert object

	{:ok, _object} = Object.prune(object)

	refute Object.get_by_ap_id(object_id)

	{:ok, %Object{} = object_two} = Fetcher.fetch_object_from_id(object_id)

	assert object.data["id"] == object_two.data["id"]
	assert object.id != object_two.id
	end
	end

	describe "signed fetches" do
	setup do: clear_config([:activitypub, :sign_object_fetches])

	test_with_mock "it signs fetches when configured to do so",
	Pleroma.Signature,
	[:passthrough],
	[] do
	clear_config([:activitypub, :sign_object_fetches], true)

	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert called(Pleroma.Signature.sign(:_, :_))
	end

	test_with_mock "it doesn't sign fetches when not configured to do so",
	Pleroma.Signature,
	[:passthrough],
	[] do
	clear_config([:activitypub, :sign_object_fetches], false)

	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	refute called(Pleroma.Signature.sign(:_, :_))
	end
	end

	describe "refetching" do
	setup do
	object1 = %{
	"id" => "https://mastodon.social/1",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"type" => "Note",
	"content" => "test 1",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => ""
	}

	object2 = %{
	"id" => "https://mastodon.social/2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"type" => "Note",
	"content" => "test 2",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => "",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "orig 2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => ""
	}
	],
	"totalItems" => 1
	}
	}

	mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/1"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: Jason.encode!(object1)
	}

	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: Jason.encode!(object2)
	}

	%{
	method: :get,
	url: "https://mastodon.social/users/emelie/collections/featured"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body:
	Jason.encode!(%{
	"id" => "https://mastodon.social/users/emelie/collections/featured",
	"type" => "OrderedCollection",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"orderedItems" => [],
	"totalItems" => 0
	})
	}

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

	%{object1: object1, object2: object2}
	end

	test "it keeps formerRepresentations if remote does not have this attr", %{object1: object1} do
	full_object1 =
	object1
	\|> Map.merge(%{
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "orig 2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => ""
	}
	],
	"totalItems" => 1
	}
	})

	{:ok, o} = Object.create(full_object1)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"content" => "orig 2"}]}} =
	refetched.data
	end

	test "it uses formerRepresentations from remote if possible", %{object2: object2} do
	{:ok, o} = Object.create(object2)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"content" => "orig 2"}]}} =
	refetched.data
	end

	test "it replaces formerRepresentations with the one from remote", %{object2: object2} do
	full_object2 =
	object2
	\|> Map.merge(%{
	"content" => "mew mew #def",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{"type" => "Note", "content" => "mew mew 2"}
	],
	"totalItems" => 1
	}
	})

	{:ok, o} = Object.create(full_object2)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{
	"content" => "test 2",
	"formerRepresentations" => %{"orderedItems" => [%{"content" => "orig 2"}]}
	} = refetched.data
	end

	test "it adds to formerRepresentations if the remote does not have one and the object has changed",
	%{object1: object1} do
	full_object1 =
	object1
	\|> Map.merge(%{
	"content" => "mew mew #def",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{"type" => "Note", "content" => "mew mew 1"}
	],
	"totalItems" => 1
	}
	})

	{:ok, o} = Object.create(full_object1)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{
	"content" => "test 1",
	"formerRepresentations" => %{
	"orderedItems" => [
	%{"content" => "mew mew #def"},
	%{"content" => "mew mew 1"}
	],
	"totalItems" => 2
	}
	} = refetched.data
	end
	end

	describe "fetch with history" do
	setup do
	object2 = %{
	"id" => "https://mastodon.social/2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"type" => "Note",
	"content" => "test 2",
	"bcc" => [],
	"bto" => [],
	"cc" => ["https://mastodon.social/users/emelie/followers"],
	"to" => [],
	"summary" => "",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "orig 2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"bcc" => [],
	"bto" => [],
	"cc" => ["https://mastodon.social/users/emelie/followers"],
	"to" => [],
	"summary" => ""
	}
	],
	"totalItems" => 1
	}
	}

	mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: Jason.encode!(object2)
	}

	%{
	method: :get,
	url: "https://mastodon.social/users/emelie/collections/featured"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body:
	Jason.encode!(%{
	"id" => "https://mastodon.social/users/emelie/collections/featured",
	"type" => "OrderedCollection",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"orderedItems" => [],
	"totalItems" => 0
	})
	}

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

	%{object2: object2}
	end

	test "it gets history", %{object2: object2} do
	{:ok, object} = Fetcher.fetch_object_from_id(object2["id"])

	assert %{
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [%{}]
	}
	} = object.data
	end
	end

	describe "get_object/1" do
	test "should return ok if the content type is application/activity+json" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: "{}"
	}
	end)

	assert {:ok, "{}"} = Fetcher.get_object("https://mastodon.social/2")
	end

	test "should return ok if the content type is application/ld+json with a profile" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [
	{"content-type",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""}
	],
	body: "{}"
	}
	end)

	assert {:ok, "{}"} = Fetcher.get_object("https://mastodon.social/2")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [
	{"content-type",
	"application/ld+json; profile=\"http://www.w3.org/ns/activitystreams\""}
	],
	body: "{}"
	}
	end)

	assert {:ok, "{}"} = Fetcher.get_object("https://mastodon.social/2")
	end

	test "should not return ok with other content types" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: "{}"
	}
	end)

	assert {:error, {:content_type, "application/json"}} =
	Fetcher.get_object("https://mastodon.social/2")
	end
	end
	end
	diff --git a/test/pleroma/search/elasticsearch_test.exs b/test/pleroma/search/elasticsearch_test.exs
	index 05725f7a7..a1c25c9c3 100644
	--- a/test/pleroma/search/elasticsearch_test.exs
	+++ b/test/pleroma/search/elasticsearch_test.exs
	@@ -1,120 +1,121 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Search.ElasticsearchTest do
	require Pleroma.Constants

	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.SearchIndexingWorker

	describe "elasticsearch" do
	setup do
	clear_config([Pleroma.Search, :module], Pleroma.Search.Elasticsearch)
	clear_config([Pleroma.Search.Elasticsearch.Cluster, :api], Pleroma.ElasticsearchMock)
	end

	setup_with_mocks(
	[
	{Pleroma.Search.Elasticsearch, [:passthrough],
	[
	add_to_index: fn a -> passthrough([a]) end,
	remove_from_index: fn a -> passthrough([a]) end
	]},
	{Elasticsearch, [:passthrough],
	[
	put_document: fn _, _, _ -> :ok end,
	delete_document: fn _, _, _ -> :ok end
	]}
	],
	context,
	do: {:ok, context}
	)

	test "indexes a local post on creation" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "guys i just don't wanna leave the swamp",
	visibility: "public"
	})

	args = %{"op" => "add_to_index", "activity" => activity.id}

	assert_enqueued(
	worker: SearchIndexingWorker,
	args: args
	)

	assert :ok = perform_job(SearchIndexingWorker, args)

	assert_called(Pleroma.Search.Elasticsearch.add_to_index(activity))
	end

	test "doesn't index posts that are not public" do
	user = insert(:user)

	Enum.each(["private", "direct"], fn visibility ->
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "guys i just don't wanna leave the swamp",
	visibility: visibility
	})

	args = %{"op" => "add_to_index", "activity" => activity.id}

	assert_enqueued(worker: SearchIndexingWorker, args: args)
	assert :ok = perform_job(SearchIndexingWorker, args)

	assert_not_called(Elasticsearch.put_document(:_))
	end)

	history = call_history(Pleroma.Search.Elasticsearch)
	assert Enum.count(history) == 2
	end

	test "deletes posts from index when deleted locally" do
	user = insert(:user)

	mock_global(fn
	%{method: :put, url: "http://127.0.0.1:7700/indexes/objects/documents", body: body} ->
	assert match?(
	[%{"content" => "guys i just don't wanna leave the swamp"}],
	Jason.decode!(body)
	)

	json(%{updateId: 1})

	%{method: :delete, url: "http://127.0.0.1:7700/indexes/objects/documents/" <> id} ->
	assert String.length(id) > 1
	json(%{updateId: 2})
	end)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "guys i just don't wanna leave the swamp",
	visibility: "public"
	})

	args = %{"op" => "add_to_index", "activity" => activity.id}
	assert_enqueued(worker: SearchIndexingWorker, args: args)
	assert :ok = perform_job(SearchIndexingWorker, args)

	{:ok, _} = CommonAPI.delete(activity.id, user)

	delete_args = %{"op" => "remove_from_index", "object" => activity.object.id}
	assert_enqueued(worker: SearchIndexingWorker, args: delete_args)
	assert :ok = perform_job(SearchIndexingWorker, delete_args)

	assert_called(Pleroma.Search.Elasticsearch.remove_from_index(:_))
	end
	end
	end
	diff --git a/test/pleroma/search/meilisearch_test.exs b/test/pleroma/search/meilisearch_test.exs
	index f51e04eb1..0a39b2004 100644
	--- a/test/pleroma/search/meilisearch_test.exs
	+++ b/test/pleroma/search/meilisearch_test.exs
	@@ -1,129 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Search.MeilisearchTest do
	require Pleroma.Constants

	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	alias Pleroma.Search.Meilisearch
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.SearchIndexingWorker

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

	describe "meilisearch" do
	setup do: clear_config([Pleroma.Search, :module], Meilisearch)

	setup_with_mocks(
	[
	{Meilisearch, [:passthrough],
	[
	add_to_index: fn a -> passthrough([a]) end,
	remove_from_index: fn a -> passthrough([a]) end,
	meili_put: fn u, a -> passthrough([u, a]) end
	]}
	],
	context,
	do: {:ok, context}
	)

	test "indexes a local post on creation" do
	user = insert(:user)

	mock_global(fn
	%{method: :put, url: "http://127.0.0.1:7700/indexes/objects/documents", body: body} ->
	assert match?(
	[%{"content" => "guys i just don't wanna leave the swamp"}],
	Jason.decode!(body)
	)

	json(%{taskUid: 1})
	end)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "guys i just don't wanna leave the swamp",
	visibility: "public"
	})

	args = %{"op" => "add_to_index", "activity" => activity.id}

	assert_enqueued(
	worker: SearchIndexingWorker,
	args: args
	)

	assert :ok = perform_job(SearchIndexingWorker, args)

	assert_called(Meilisearch.add_to_index(activity))
	end

	test "doesn't index posts that are not public" do
	user = insert(:user)

	Enum.each(["private", "direct"], fn visibility ->
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "guys i just don't wanna leave the swamp",
	visibility: visibility
	})

	args = %{"op" => "add_to_index", "activity" => activity.id}

	assert_enqueued(worker: SearchIndexingWorker, args: args)
	assert :ok = perform_job(SearchIndexingWorker, args)

	assert_not_called(Meilisearch.meili_put(:_))
	end)

	history = call_history(Meilisearch)
	assert Enum.count(history) == 2
	end

	test "deletes posts from index when deleted locally" do
	user = insert(:user)

	mock_global(fn
	%{method: :put, url: "http://127.0.0.1:7700/indexes/objects/documents", body: body} ->
	assert match?(
	[%{"content" => "guys i just don't wanna leave the swamp"}],
	Jason.decode!(body)
	)

	json(%{taskUid: 1})

	%{method: :delete, url: "http://127.0.0.1:7700/indexes/objects/documents/" <> id} ->
	assert String.length(id) > 1
	json(%{taskUid: 2})
	end)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "guys i just don't wanna leave the swamp",
	visibility: "public"
	})

	args = %{"op" => "add_to_index", "activity" => activity.id}
	assert_enqueued(worker: SearchIndexingWorker, args: args)
	assert :ok = perform_job(SearchIndexingWorker, args)

	{:ok, _} = CommonAPI.delete(activity.id, user)

	delete_args = %{"op" => "remove_from_index", "object" => activity.object.id}
	assert_enqueued(worker: SearchIndexingWorker, args: delete_args)
	assert :ok = perform_job(SearchIndexingWorker, delete_args)

	assert_called(Meilisearch.remove_from_index(:_))
	end
	end
	end
	diff --git a/test/pleroma/signature_test.exs b/test/pleroma/signature_test.exs
	index a94610e66..1f52484a5 100644
	--- a/test/pleroma/signature_test.exs
	+++ b/test/pleroma/signature_test.exs
	@@ -1,144 +1,145 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.SignatureTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	alias Pleroma.Signature

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	@private_key "-----BEGIN RSA PRIVATE KEY-----\nMIIEpQIBAAKCAQEA48qb4v6kqigZutO9Ot0wkp27GIF2LiVaADgxQORZozZR63jH\nTaoOrS3Xhngbgc8SSOhfXET3omzeCLqaLNfXnZ8OXmuhJfJSU6mPUvmZ9QdT332j\nfN/g3iWGhYMf/M9ftCKh96nvFVO/tMruzS9xx7tkrfJjehdxh/3LlJMMImPtwcD7\nkFXwyt1qZTAU6Si4oQAJxRDQXHp1ttLl3Ob829VM7IKkrVmY8TD+JSlV0jtVJPj6\n1J19ytKTx/7UaucYvb9HIiBpkuiy5n/irDqKLVf5QEdZoNCdojOZlKJmTLqHhzKP\n3E9TxsUjhrf4/EqegNc/j982RvOxeu4i40zMQwIDAQABAoIBAQDH5DXjfh21i7b4\ncXJuw0cqget617CDUhemdakTDs9yH+rHPZd3mbGDWuT0hVVuFe4vuGpmJ8c+61X0\nRvugOlBlavxK8xvYlsqTzAmPgKUPljyNtEzQ+gz0I+3mH2jkin2rL3D+SksZZgKm\nfiYMPIQWB2WUF04gB46DDb2mRVuymGHyBOQjIx3WC0KW2mzfoFUFRlZEF+Nt8Ilw\nT+g/u0aZ1IWoszbsVFOEdghgZET0HEarum0B2Je/ozcPYtwmU10iBANGMKdLqaP/\nj954BPunrUf6gmlnLZKIKklJj0advx0NA+cL79+zeVB3zexRYSA5o9q0WPhiuTwR\n/aedWHnBAoGBAP0sDWBAM1Y4TRAf8ZI9PcztwLyHPzfEIqzbObJJnx1icUMt7BWi\n+/RMOnhrlPGE1kMhOqSxvXYN3u+eSmWTqai2sSH5Hdw2EqnrISSTnwNUPINX7fHH\njEkgmXQ6ixE48SuBZnb4w1EjdB/BA6/sjL+FNhggOc87tizLTkMXmMtTAoGBAOZV\n+wPuAMBDBXmbmxCuDIjoVmgSlgeRunB1SA8RCPAFAiUo3+/zEgzW2Oz8kgI+xVwM\n33XkLKrWG1Orhpp6Hm57MjIc5MG+zF4/YRDpE/KNG9qU1tiz0UD5hOpIU9pP4bR/\ngxgPxZzvbk4h5BfHWLpjlk8UUpgk6uxqfti48c1RAoGBALBOKDZ6HwYRCSGMjUcg\n3NPEUi84JD8qmFc2B7Tv7h2he2ykIz9iFAGpwCIyETQsJKX1Ewi0OlNnD3RhEEAy\nl7jFGQ+mkzPSeCbadmcpYlgIJmf1KN/x7fDTAepeBpCEzfZVE80QKbxsaybd3Dp8\nCfwpwWUFtBxr4c7J+gNhAGe/AoGAPn8ZyqkrPv9wXtyfqFjxQbx4pWhVmNwrkBPi\nZ2Qh3q4dNOPwTvTO8vjghvzIyR8rAZzkjOJKVFgftgYWUZfM5gE7T2mTkBYq8W+U\n8LetF+S9qAM2gDnaDx0kuUTCq7t87DKk6URuQ/SbI0wCzYjjRD99KxvChVGPBHKo\n1DjqMuECgYEAgJGNm7/lJCS2wk81whfy/ttKGsEIkyhPFYQmdGzSYC5aDc2gp1R3\nxtOkYEvdjfaLfDGEa4UX8CHHF+w3t9u8hBtcdhMH6GYb9iv6z0VBTt4A/11HUR49\n3Z7TQ18Iyh3jAUCzFV9IJlLIExq5Y7P4B3ojWFBN607sDCt8BMPbDYs=\n-----END RSA PRIVATE KEY-----"

	@public_key "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw0P/Tq4gb4G/QVuMGbJo\nC/AfMNcv+m7NfrlOwkVzcU47jgESuYI4UtJayissCdBycHUnfVUd9qol+eznSODz\nCJhfJloqEIC+aSnuEPGA0POtWad6DU0E6/Ho5zQn5WAWUwbRQqowbrsm/GHo2+3v\neR5jGenwA6sYhINg/c3QQbksyV0uJ20Umyx88w8+TJuv53twOfmyDWuYNoQ3y5cc\nHKOZcLHxYOhvwg3PFaGfFHMFiNmF40dTXt9K96r7sbzc44iLD+VphbMPJEjkMuf8\nPGEFOBzy8pm3wJZw2v32RNW2VESwMYyqDzwHXGSq1a73cS7hEnc79gXlELsK04L9\nQQIDAQAB\n-----END PUBLIC KEY-----\n"

	@rsa_public_key {
	:RSAPublicKey,
	24_650_000_183_914_698_290_885_268_529_673_621_967_457_234_469_123_179_408_466_269_598_577_505_928_170_923_974_132_111_403_341_217_239_999_189_084_572_368_839_502_170_501_850_920_051_662_384_964_248_315_257_926_552_945_648_828_895_432_624_227_029_881_278_113_244_073_644_360_744_504_606_177_648_469_825_063_267_913_017_309_199_785_535_546_734_904_379_798_564_556_494_962_268_682_532_371_146_333_972_821_570_577_277_375_020_977_087_539_994_500_097_107_935_618_711_808_260_846_821_077_839_605_098_669_707_417_692_791_905_543_116_911_754_774_323_678_879_466_618_738_207_538_013_885_607_095_203_516_030_057_611_111_308_904_599_045_146_148_350_745_339_208_006_497_478_057_622_336_882_506_112_530_056_970_653_403_292_123_624_453_213_574_011_183_684_739_084_105_206_483_178_943_532_208_537_215_396_831_110_268_758_639_826_369_857,
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	65_537
	}

	defp make_fake_signature(key_id), do: "keyId=\"#{key_id}\""

	defp make_fake_conn(key_id),
	do: %Plug.Conn{req_headers: %{"signature" => make_fake_signature(key_id <> "#main-key")}}

	describe "fetch_public_key/1" do
	test "it returns key" do
	expected_result = {:ok, @rsa_public_key}

	user = insert(:user, public_key: @public_key)

	assert Signature.fetch_public_key(make_fake_conn(user.ap_id)) == expected_result
	end

	test "it returns error when not found user" do
	assert capture_log(fn ->
	assert Signature.fetch_public_key(make_fake_conn("https://test-ap-id")) ==
	{:error, :error}
	end) =~ "[error] Could not decode user"
	end

	test "it returns error if public key is nil" do
	user = insert(:user, public_key: nil)

	assert Signature.fetch_public_key(make_fake_conn(user.ap_id)) == {:error, :error}
	end
	end

	describe "refetch_public_key/1" do
	test "it returns key" do
	ap_id = "https://mastodon.social/users/lambadalambda"

	assert Signature.refetch_public_key(make_fake_conn(ap_id)) == {:ok, @rsa_public_key}
	end

	test "it returns error when not found user" do
	assert capture_log(fn ->
	{:error, _} = Signature.refetch_public_key(make_fake_conn("https://test-ap_id"))
	end) =~ "[error] Could not decode user"
	end
	end

	describe "sign/2" do
	test "it returns signature headers" do
	user =
	insert(:user, %{
	ap_id: "https://mastodon.social/users/lambadalambda",
	keys: @private_key
	})

	assert Signature.sign(
	user,
	%{
	host: "test.test",
	"content-length": 100
	}
	) ==
	"keyId=\"https://mastodon.social/users/lambadalambda#main-key\",algorithm=\"rsa-sha256\",headers=\"content-length host\",signature=\"sibUOoqsFfTDerquAkyprxzDjmJm6erYc42W5w1IyyxusWngSinq5ILTjaBxFvfarvc7ci1xAi+5gkBwtshRMWm7S+Uqix24Yg5EYafXRun9P25XVnYBEIH4XQ+wlnnzNIXQkU3PU9e6D8aajDZVp3hPJNeYt1gIPOA81bROI8/glzb1SAwQVGRbqUHHHKcwR8keiR/W2h7BwG3pVRy4JgnIZRSW7fQogKedDg02gzRXwUDFDk0pr2p3q6bUWHUXNV8cZIzlMK+v9NlyFbVYBTHctAR26GIAN6Hz0eV0mAQAePHDY1mXppbA8Gpp6hqaMuYfwifcXmcc+QFm4e+n3A==\""
	end

	test "it returns error" do
	user = insert(:user, %{ap_id: "https://mastodon.social/users/lambadalambda", keys: ""})

	assert Signature.sign(
	user,
	%{host: "test.test", "content-length": 100}
	) == {:error, []}
	end
	end

	describe "key_id_to_actor_id/1" do
	test "it properly deduces the actor id for misskey" do
	assert Signature.key_id_to_actor_id("https://example.com/users/1234/publickey") ==
	{:ok, "https://example.com/users/1234"}
	end

	test "it properly deduces the actor id for mastodon and pleroma" do
	assert Signature.key_id_to_actor_id("https://example.com/users/1234#main-key") ==
	{:ok, "https://example.com/users/1234"}
	end

	test "it deduces the actor id for gotoSocial" do
	assert Signature.key_id_to_actor_id("https://example.com/users/1234/main-key") ==
	{:ok, "https://example.com/users/1234"}
	end

	test "it deduces the actor ID for streams" do
	assert Signature.key_id_to_actor_id("https://example.com/users/1234?operation=getkey") ==
	{:ok, "https://example.com/users/1234"}
	end

	test "it calls webfinger for 'acct:' accounts" do
	with_mock(Pleroma.Web.WebFinger,
	finger: fn _ -> {:ok, %{"ap_id" => "https://gensokyo.2hu/users/raymoo"}} end
	) do
	assert Signature.key_id_to_actor_id("acct:raymoo@gensokyo.2hu") ==
	{:ok, "https://gensokyo.2hu/users/raymoo"}
	end
	end
	end

	describe "signed_date" do
	test "it returns formatted current date" do
	with_mock(NaiveDateTime, utc_now: fn -> ~N[2019-08-23 18:11:24.822233] end) do
	assert Signature.signed_date() == "Fri, 23 Aug 2019 18:11:24 GMT"
	end
	end

	test "it returns formatted date" do
	assert Signature.signed_date(~N[2019-08-23 08:11:24.822233]) ==
	"Fri, 23 Aug 2019 08:11:24 GMT"
	end
	end
	end
	diff --git a/test/pleroma/upload/filter/mogrifun_test.exs b/test/pleroma/upload/filter/mogrifun_test.exs
	index 5a21017fa..54cb75e18 100644
	--- a/test/pleroma/upload/filter/mogrifun_test.exs
	+++ b/test/pleroma/upload/filter/mogrifun_test.exs
	@@ -1,44 +1,46 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.MogrifunTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	+
	import Mock

	alias Pleroma.Upload
	alias Pleroma.Upload.Filter

	test "apply mogrify filter" do
	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	upload = %Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	task =
	Task.async(fn ->
	assert_receive {:apply_filter, {}}, 4_000
	end)

	with_mocks([
	{Mogrify, [],
	[
	open: fn _f -> %Mogrify.Image{} end,
	custom: fn _m, _a -> send(task.pid, {:apply_filter, {}}) end,
	custom: fn _m, _a, _o -> send(task.pid, {:apply_filter, {}}) end,
	save: fn _f, _o -> :ok end
	]}
	]) do
	assert Filter.Mogrifun.filter(upload) == {:ok, :filtered}
	end

	Task.await(task)
	end
	end
	diff --git a/test/pleroma/upload/filter/mogrify_test.exs b/test/pleroma/upload/filter/mogrify_test.exs
	index 5e029a2ab..1f4ca4d37 100644
	--- a/test/pleroma/upload/filter/mogrify_test.exs
	+++ b/test/pleroma/upload/filter/mogrify_test.exs
	@@ -1,41 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.MogrifyTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	import Mock

	alias Pleroma.Upload.Filter

	test "apply mogrify filter" do
	clear_config(Filter.Mogrify, args: [{"tint", "40"}])

	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	upload = %Pleroma.Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	task =
	Task.async(fn ->
	assert_receive {:apply_filter, {_, "tint", "40"}}, 4_000
	end)

	with_mock Mogrify,
	open: fn _f -> %Mogrify.Image{} end,
	custom: fn _m, _a -> :ok end,
	custom: fn m, a, o -> send(task.pid, {:apply_filter, {m, a, o}}) end,
	save: fn _f, _o -> :ok end do
	assert Filter.Mogrify.filter(upload) == {:ok, :filtered}
	end

	Task.await(task)
	end
	end
	diff --git a/test/pleroma/uploaders/s3_test.exs b/test/pleroma/uploaders/s3_test.exs
	index 215bb74f6..804710509 100644
	--- a/test/pleroma/uploaders/s3_test.exs
	+++ b/test/pleroma/uploaders/s3_test.exs
	@@ -1,89 +1,90 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Uploaders.S3Test do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Uploaders.S3

	import Mock
	import ExUnit.CaptureLog

	setup do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
	clear_config([Pleroma.Uploaders.S3])
	clear_config([Pleroma.Uploaders.S3, :bucket], "test_bucket")
	end

	describe "get_file/1" do
	test "it returns path to local folder for files" do
	assert S3.get_file("test_image.jpg") == {
	:ok,
	{:url, "https://s3.amazonaws.com/test_bucket/test_image.jpg"}
	}
	end

	test "it returns path without bucket when truncated_namespace set to ''" do
	clear_config([Pleroma.Uploaders.S3],
	bucket: "test_bucket",
	bucket_namespace: "myaccount",
	truncated_namespace: ""
	)

	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")

	assert S3.get_file("test_image.jpg") == {
	:ok,
	{:url, "https://s3.amazonaws.com/test_image.jpg"}
	}
	end

	test "it returns path with bucket namespace when namespace is set" do
	clear_config([Pleroma.Uploaders.S3],
	bucket: "test_bucket",
	bucket_namespace: "family"
	)

	assert S3.get_file("test_image.jpg") == {
	:ok,
	{:url, "https://s3.amazonaws.com/family:test_bucket/test_image.jpg"}
	}
	end
	end

	describe "put_file/1" do
	setup do
	file_upload = %Pleroma.Upload{
	name: "image-tet.jpg",
	content_type: "image/jpeg",
	path: "test_folder/image-tet.jpg",
	tempfile: Path.absname("test/instance_static/add/shortcode.png")
	}

	[file_upload: file_upload]
	end

	test "save file", %{file_upload: file_upload} do
	with_mock ExAws, request: fn _ -> {:ok, :ok} end do
	assert S3.put_file(file_upload) == {:ok, {:file, "test_folder/image-tet.jpg"}}
	end
	end

	test "returns error", %{file_upload: file_upload} do
	with_mock ExAws, request: fn _ -> {:error, "S3 Upload failed"} end do
	assert capture_log(fn ->
	assert S3.put_file(file_upload) == {:error, "S3 Upload failed"}
	end) =~ "Elixir.Pleroma.Uploaders.S3: {:error, \"S3 Upload failed\"}"
	end
	end
	end

	describe "delete_file/1" do
	test_with_mock "deletes file", ExAws, request: fn _req -> {:ok, %{status_code: 204}} end do
	assert :ok = S3.delete_file("image.jpg")
	assert_called(ExAws.request(:_))
	end
	end
	end
	diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
	index 94b499711..9c4c8089c 100644
	--- a/test/pleroma/user/backup_test.exs
	+++ b/test/pleroma/user/backup_test.exs
	@@ -1,277 +1,278 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.BackupTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	import Mock
	import Pleroma.Factory
	import Swoosh.TestAssertions

	alias Pleroma.Bookmark
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User.Backup
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.BackupWorker

	setup do
	clear_config([Pleroma.Upload, :uploader])
	clear_config([Backup, :limit_days])
	clear_config([Pleroma.Emails.Mailer, :enabled], true)
	end

	test "it does not requrie enabled email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	user = insert(:user)
	assert {:ok, _} = Backup.create(user)
	end

	test "it does not require user's email" do
	user = insert(:user, %{email: nil})
	assert {:ok, _} = Backup.create(user)
	end

	test "it creates a backup record and an Oban job" do
	%{id: user_id} = user = insert(:user)
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	assert_enqueued(worker: BackupWorker, args: args)

	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup
	end

	test "it return an error if the export limit is over" do
	%{id: user_id} = user = insert(:user)
	limit_days = Pleroma.Config.get([Backup, :limit_days])
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup

	assert Backup.create(user) == {:error, "Last export was less than #{limit_days} days ago"}
	end

	test "it process a backup record" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it does not send an email if the user does not have an email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: nil})

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it does not send an email if mailer is not on" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it does not send an email if the user has an empty email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: ""})

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it removes outdated backups after creating a fresh one" do
	clear_config([Backup, :limit_days], -1)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	user = insert(:user)

	assert {:ok, job1} = Backup.create(user)

	assert {:ok, %Backup{}} = ObanHelpers.perform(job1)
	assert {:ok, job2} = Backup.create(user)
	assert Pleroma.Repo.aggregate(Backup, :count) == 2
	assert {:ok, backup2} = ObanHelpers.perform(job2)

	ObanHelpers.perform_all()

	assert [^backup2] = Pleroma.Repo.all(Backup)
	end

	test "it creates a zip archive with user data" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	{:ok, %{object: %{data: %{"id" => id1}}} = status1} =
	CommonAPI.post(user, %{status: "status1"})

	{:ok, %{object: %{data: %{"id" => id2}}} = status2} =
	CommonAPI.post(user, %{status: "status2"})

	{:ok, %{object: %{data: %{"id" => id3}}} = status3} =
	CommonAPI.post(user, %{status: "status3"})

	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)

	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup)
	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
	assert {:ok, {~c"actor.json", json}} = :zip.zip_get(~c"actor.json", zipfile)

	assert %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{"@language" => "und"}
	],
	"bookmarks" => "bookmarks.json",
	"followers" => "http://cofe.io/users/cofe/followers",
	"following" => "http://cofe.io/users/cofe/following",
	"id" => "http://cofe.io/users/cofe",
	"inbox" => "http://cofe.io/users/cofe/inbox",
	"likes" => "likes.json",
	"name" => "Cofe",
	"outbox" => "http://cofe.io/users/cofe/outbox",
	"preferredUsername" => "cofe",
	"publicKey" => %{
	"id" => "http://cofe.io/users/cofe#main-key",
	"owner" => "http://cofe.io/users/cofe"
	},
	"type" => "Person",
	"url" => "http://cofe.io/users/cofe"
	} = Jason.decode!(json)

	assert {:ok, {~c"outbox.json", json}} = :zip.zip_get(~c"outbox.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "outbox.json",
	"orderedItems" => [
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status1",
	"type" => "Note"
	},
	"type" => "Create"
	},
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status2"
	}
	},
	%{
	"actor" => "http://cofe.io/users/cofe",
	"object" => %{
	"content" => "status3"
	}
	}
	],
	"totalItems" => 3,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {~c"likes.json", json}} = :zip.zip_get(~c"likes.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "likes.json",
	"orderedItems" => [^id1, ^id2],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {~c"bookmarks.json", json}} = :zip.zip_get(~c"bookmarks.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "bookmarks.json",
	"orderedItems" => [^id2, ^id3],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	:zip.zip_close(zipfile)
	File.rm!(path)
	end

	describe "it uploads and deletes a backup archive" do
	setup do
	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
	clear_config([Pleroma.Uploaders.S3, :bucket], "test_bucket")

	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	{:ok, status1} = CommonAPI.post(user, %{status: "status1"})
	{:ok, status2} = CommonAPI.post(user, %{status: "status2"})
	{:ok, status3} = CommonAPI.post(user, %{status: "status3"})
	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)
	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup)

	[path: path, backup: backup]
	end

	test "S3", %{path: path, backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
	clear_config([Pleroma.Uploaders.S3, :streaming_enabled], false)

	with_mock ExAws,
	request: fn
	%{http_method: :put} -> {:ok, :ok}
	%{http_method: :delete} -> {:ok, %{status_code: 204}}
	end do
	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end

	clear_config([Pleroma.Upload, :uploader])
	end

	test "Local", %{path: path, backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end
	end
	end
	diff --git a/test/pleroma/user_relationship_test.exs b/test/pleroma/user_relationship_test.exs
	index b3a0dbe37..dcd001cdd 100644
	--- a/test/pleroma/user_relationship_test.exs
	+++ b/test/pleroma/user_relationship_test.exs
	@@ -1,136 +1,137 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserRelationshipTest do
	alias Pleroma.UserRelationship

	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	import Mock
	import Pleroma.Factory

	describe "*_exists?/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "returns false if record doesn't exist", %{users: [user1, user2]} do
	refute UserRelationship.block_exists?(user1, user2)
	refute UserRelationship.mute_exists?(user1, user2)
	refute UserRelationship.notification_mute_exists?(user1, user2)
	refute UserRelationship.reblog_mute_exists?(user1, user2)
	refute UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "returns true if record exists", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	assert UserRelationship.block_exists?(user1, user2)
	assert UserRelationship.mute_exists?(user1, user2)
	assert UserRelationship.notification_mute_exists?(user1, user2)
	assert UserRelationship.reblog_mute_exists?(user1, user2)
	assert UserRelationship.inverse_subscription_exists?(user1, user2)
	end
	end

	describe "create_*/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "creates user relationship record if it doesn't exist", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	UserRelationship.create_block(user1, user2)
	UserRelationship.create_mute(user1, user2)
	UserRelationship.create_notification_mute(user1, user2)
	UserRelationship.create_reblog_mute(user1, user2)
	UserRelationship.create_inverse_subscription(user1, user2)

	assert UserRelationship.block_exists?(user1, user2)
	assert UserRelationship.mute_exists?(user1, user2)
	assert UserRelationship.notification_mute_exists?(user1, user2)
	assert UserRelationship.reblog_mute_exists?(user1, user2)
	assert UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "if record already exists, returns it", %{users: [user1, user2]} do
	user_block =
	with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
	{:ok, %{inserted_at: ~N[2017-03-17 17:09:58]}} =
	UserRelationship.create_block(user1, user2)
	end

	assert user_block == UserRelationship.create_block(user1, user2)
	end
	end

	describe "delete_*/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "deletes user relationship record if it exists", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	assert {:ok, %UserRelationship{}} = UserRelationship.delete_block(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_mute(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_notification_mute(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_reblog_mute(user1, user2)

	assert {:ok, %UserRelationship{}} =
	UserRelationship.delete_inverse_subscription(user1, user2)

	refute UserRelationship.block_exists?(user1, user2)
	refute UserRelationship.mute_exists?(user1, user2)
	refute UserRelationship.notification_mute_exists?(user1, user2)
	refute UserRelationship.reblog_mute_exists?(user1, user2)
	refute UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "if record does not exist, returns {:ok, nil}", %{users: [user1, user2]} do
	assert {:ok, nil} = UserRelationship.delete_block(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_notification_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_reblog_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_inverse_subscription(user1, user2)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_test.exs b/test/pleroma/web/activity_pub/activity_pub_test.exs
	index e67c80760..d4d1c2aac 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_test.exs
	@@ -1,2654 +1,2655 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Mock
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([Pleroma.Uploaders.Local, :uploads], "uploads")
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

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

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "works for guppe actors" do
	user_id = "https://gup.pe/u/bernie2020"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/guppe-actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.name == "Bernie2020 group"
	assert user.actor_type == "Group"
	end

	test "works for bridgy actors" do
	user_id = "https://fed.brid.gy/jk.nipponalba.scot"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/bridgy/actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.actor_type == "Person"

	assert user.avatar == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	}

	assert user.banner == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	}
	end

	test "fetches user featured collection" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

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

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

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

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

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)
	Process.sleep(50)

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end
	end

	test "fetches user featured collection using the first property" do
	featured_url = "https://friendica.example.com/raha/collections/featured"
	first_url = "https://friendica.example.com/featured/raha?page=1"

	featured_data =
	"test/fixtures/friendica/friendica_featured_collection.json"
	\|> File.read!()

	page_data =
	"test/fixtures/friendica/friendica_featured_collection_first.json"
	\|> File.read!()

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

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

	{:ok, data} = ActivityPub.fetch_and_prepare_featured_from_ap_id(featured_url)
	assert Map.has_key?(data, "http://inserted")
	end

	test "fetches user featured when it has string IDs" do
	featured_url = "https://example.com/alisaie/collections/featured"
	dead_url = "https://example.com/users/alisaie/statuses/108311386746229284"

	featured_data =
	"test/fixtures/mastodon/featured_collection.json"
	\|> File.read!()

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

	%{
	method: :get,
	url: ^dead_url
	} ->
	%Tesla.Env{
	status: 404,
	body: "{}",
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, %{}} = ActivityPub.fetch_and_prepare_featured_from_ap_id(featured_url)
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #TEST"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #Reject"})

	{:ok, status_four} = CommonAPI.post(user, %{status: ". #Any1 #any2"})
	{:ok, status_five} = CommonAPI.post(user, %{status: ". #Any2 #any1"})

	for hashtag_timeline_strategy <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_strategy)

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["TEST", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "Essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "REJECT"]
	})

	# Testing that deduplication (if needed) is done on DB (not Ecto) level; :limit is important
	fetch_five =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["ANY1", "any2"],
	limit: 2
	})

	fetch_six =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["any1", "Any2"],
	tag_all: [],
	tag_reject: []
	})

	# Regression test: passing empty lists as filter options shouldn't affect the results
	assert fetch_five == fetch_six

	[fetch_one, fetch_two, fetch_three, fetch_four, fetch_five] =
	Enum.map([fetch_one, fetch_two, fetch_three, fetch_four, fetch_five], fn statuses ->
	Enum.map(statuses, fn s -> Repo.preload(s, object: :hashtags) end)
	end)

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	assert fetch_five == [status_four, status_five]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity, fetch: false)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity, fetch: false)
	assert is_binary(object.data["id"])
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	test "it reverts create", %{user: user} do
	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:ok, _} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	},
	additional: %{
	"expires_at" => DateTime.utc_now()
	}
	})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities for followed hashtags" do
	test "it should return public activities that reference a given hashtag" do
	hashtag = insert(:hashtag, name: "tenshi")
	user = insert(:user)
	other_user = insert(:user)

	{:ok, normally_visible} =
	CommonAPI.post(other_user, %{status: "hello :)", visibility: "public"})

	{:ok, public} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "public"})
	{:ok, _unrelated} = CommonAPI.post(user, %{status: "dai #tensh", visibility: "public"})
	{:ok, unlisted} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "unlisted"})
	{:ok, _private} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([other_user.follower_address], %{
	followed_hashtags: [hashtag.id]
	})

	assert length(activities) == 3
	normal_id = normally_visible.id
	public_id = public.id
	unlisted_id = unlisted.id
	assert [%{id: ^normal_id}, %{id: ^public_id}, %{id: ^unlisted_id}] = activities
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	insert(:filter, user: user, phrase: "test", hide: true)

	{:ok, %{id: id1, data: %{"context" => context}}} = CommonAPI.post(user, %{status: "1"})

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	\|> ActivityPub.fetch_activities_for_context(%{user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return activities from deactivated users" do
	_user = insert(:user)
	deactivated = insert(:user)
	active = insert(:user)
	{:ok, activity_one} = CommonAPI.post(deactivated, %{status: "hey!"})
	{:ok, activity_two} = CommonAPI.post(active, %{status: "yay!"})
	{:ok, _updated_user} = User.set_activation(deactivated, false)

	activities = ActivityPub.fetch_activities([], %{})

	refute Enum.member?(activities, activity_one)
	assert Enum.member?(activities, activity_two)
	end

	test "always see your own posts even when they address people you block" do
	user = insert(:user)
	blockee = insert(:user)

	{:ok, _} = User.block(user, blockee)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{blockee.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

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

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

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

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

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

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two, fetch: false)

	data = %{
	"actor" => friend.ap_id,
	"object" => object.data["id"],
	"context" => object.data["context"],
	"type" => "Announce",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [blockee.ap_id]
	}

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(user, followed_user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "see your own posts even when they adress actors from blocked domains" do
	user = insert(:user)

	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})

	{:ok, user} = User.block_domain(user, domain)

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

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker, domain_user} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "returns your own posts regardless of mute" do
	user = insert(:user)
	muted = insert(:user)

	{:ok, muted_post} = CommonAPI.post(muted, %{status: "Im stupid"})

	{:ok, reply} =
	CommonAPI.post(user, %{status: "I'm muting you", in_reply_to_status_id: muted_post.id})

	{:ok, _} = User.mute(user, muted)

	[activity] = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert activity.id == reply.id
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

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

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	insert(:filter, user: user_two, phrase: "cofe", hide: true)
	insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	insert(:filter, user: user_two, phrase: "test", hide: false)

	params = %{
	type: ["Create", "Announce"],
	user: user_two
	}

	{:ok, %{user: user, user_two: user_two, params: params}}
	end

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(user, booster)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "strips / from filename", %{test_file: file} do
	file = %Plug.Upload{file \| filename: "../../../../../nested/bad.jpg"}
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	[%{"href" => href}] = object.data["url"]
	assert Regex.match?(~r"/bad.jpg$", href)
	refute Regex.match?(~r"/nested/", href)
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{is_locked: true})

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "it removes the follow activity if it was local" do
	follower = insert(:user, local: true)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed, nil, true)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	follow_activity = Activity.get_by_id(follow_activity.id)
	assert is_nil(follow_activity)
	assert is_nil(Utils.fetch_latest_follow(follower, followed))

	# We need to keep our own undo
	undo_activity = Activity.get_by_ap_id(activity.data["id"])
	refute is_nil(undo_activity)
	end

	test "it removes the follow activity if it was remote" do
	follower = insert(:user, local: false)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed, nil, false)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	follow_activity = Activity.get_by_id(follow_activity.id)
	assert is_nil(follow_activity)
	assert is_nil(Utils.fetch_latest_follow(follower, followed))

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

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1, user3} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2, user3} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3, user2} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	activity_ap_id: activity_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => content,
	"published" => activity_with_object.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "strips status data from Flag, before federating it",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	[] do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	new_data =
	put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])

	assert_called(Utils.maybe_federate(%{activity \| data: new_data}))
	end

	test_with_mock "reverts on error",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	maybe_federate: fn _ -> {:error, :reverted} end do
	assert {:error, :reverted} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.aggregate(Object, :count, :id) == 1
	assert Repo.aggregate(Notification, :count, :id) == 0
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "synchronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

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

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

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

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:8080/followers/fuser3",
	following_address: "http://localhost:8080/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_hidden_counters/following" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/followers"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"http://localhost:4001/users/masto_hidden_counters/followers" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/following"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
	following_address: "http://localhost:4001/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(user, a4.id)
	{:ok, _} = CommonAPI.favorite(other_user, a3.id)
	{:ok, _} = CommonAPI.favorite(user, a3.id)
	{:ok, _} = CommonAPI.favorite(other_user, a5.id)
	{:ok, _} = CommonAPI.favorite(user, a5.id)
	{:ok, _} = CommonAPI.favorite(other_user, a4.id)
	{:ok, _} = CommonAPI.favorite(user, a1.id)
	{:ok, _} = CommonAPI.favorite(other_user, a1.id)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

	User.follow(follower, old_user)
	User.follow(follower_move_opted_out, old_user)

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true,
	recipients: recipients
	} = activity

	assert old_user.follower_address in recipients

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end

	test "do not move remote user following relationships" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower_remote = insert(:user, local: false)

	User.follow(follower_remote, old_user)

	assert User.following?(follower_remote, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	assert User.following?(follower_remote, old_user)
	refute User.following?(follower_remote, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

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

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

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

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

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

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u3} = User.follow(u1, u3)
	{:ok, u3, u1} = User.follow(u3, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at:
	activity.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

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

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end

	describe "reply filtering" do
	test "`following` still contains announcements by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})

	{:ok, not_followed_to_followed} =
	CommonAPI.post(not_followed, %{
	status: "Also hello",
	in_reply_to_status_id: followed_post.id
	})

	{:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

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

	followed_post_id = followed_post.id
	retoot_id = retoot.id

	assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities

	assert length(activities) == 2
	end

	# This test is skipped because, while this is the desired behavior,
	# there seems to be no good way to achieve it with the method that
	# we currently use for detecting to who a reply is directed.
	# This is a TODO and should be fixed by a later rewrite of the code
	# in question.
	@tag skip: true
	test "`following` still contains self-replies by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	{:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})

	{:ok, _followed_to_not_followed} =
	CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})

	{:ok, _followed_self_reply} =
	CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

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

	assert length(activities) == 2
	end
	end

	test "allow fetching of accounts with an empty string name field" do
	Tesla.Mock.mock(fn
	%{method: :get, url: "https://princess.cat/users/mewmew"} ->
	file = File.read!("test/fixtures/mewmew_no_name.json")
	%Tesla.Env{status: 200, body: file, headers: HttpRequestMock.activitypub_object_headers()}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id("https://princess.cat/users/mewmew")
	assert user.name == " "
	end

	describe "persist/1" do
	test "should not persist remote delete activities" do
	poster = insert(:user, local: false)
	{:ok, post} = CommonAPI.post(poster, %{status: "hhhhhh"})

	{:ok, delete_data, meta} = Builder.delete(poster, post)
	local_opts = Keyword.put(meta, :local, false)
	{:ok, act, _meta} = ActivityPub.persist(delete_data, local_opts)
	refute act.inserted_at
	end

	test "should not persist remote undo activities" do
	poster = insert(:user, local: false)
	liker = insert(:user, local: false)
	{:ok, post} = CommonAPI.post(poster, %{status: "hhhhhh"})
	{:ok, like} = CommonAPI.favorite(liker, post.id)

	{:ok, undo_data, meta} = Builder.undo(liker, like)
	local_opts = Keyword.put(meta, :local, false)
	{:ok, act, _meta} = ActivityPub.persist(undo_data, local_opts)
	refute act.inserted_at
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/media_proxy_warming_policy_test.exs b/test/pleroma/web/activity_pub/mrf/media_proxy_warming_policy_test.exs
	index 8bacedf27..e759b3fda 100644
	--- a/test/pleroma/web/activity_pub/mrf/media_proxy_warming_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/media_proxy_warming_policy_test.exs
	@@ -1,98 +1,99 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicyTest do
	use ExUnit.Case, async: false
	+ @moduletag :mocked
	use Pleroma.Tests.Helpers

	alias Pleroma.HTTP
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy

	import Mock

	@message %{
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "content",
	"attachment" => [
	%{"url" => [%{"href" => "http://example.com/image.jpg"}]}
	]
	}
	}

	@message_with_history %{
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "content",
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "content",
	"attachment" => [
	%{"url" => [%{"href" => "http://example.com/image.jpg"}]}
	]
	}
	]
	}
	}
	}

	setup do: clear_config([:media_proxy, :enabled], true)
	setup do: clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	test "it prefetches media proxy URIs" do
	Tesla.Mock.mock(fn %{method: :get, url: "http://example.com/image.jpg"} ->
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end)

	with_mock HTTP, get: fn _, _, _ -> {:ok, []} end do
	MediaProxyWarmingPolicy.filter(@message)

	assert called(HTTP.get(:_, :_, :_))
	end
	end

	test "it does nothing when no attachments are present" do
	object =
	@message["object"]
	\|> Map.delete("attachment")

	message =
	@message
	\|> Map.put("object", object)

	with_mock HTTP, get: fn _, _, _ -> {:ok, []} end do
	MediaProxyWarmingPolicy.filter(message)
	refute called(HTTP.get(:_, :_, :_))
	end
	end

	test "history-aware" do
	Tesla.Mock.mock(fn %{method: :get, url: "http://example.com/image.jpg"} ->
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end)

	with_mock HTTP, get: fn _, _, _ -> {:ok, []} end do
	MRF.filter_one(MediaProxyWarmingPolicy, @message_with_history)

	assert called(HTTP.get(:_, :_, :_))
	end
	end

	test "works with Updates" do
	Tesla.Mock.mock(fn %{method: :get, url: "http://example.com/image.jpg"} ->
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end)

	with_mock HTTP, get: fn _, _, _ -> {:ok, []} end do
	MRF.filter_one(MediaProxyWarmingPolicy, @message_with_history \|> Map.put("type", "Update"))

	assert called(HTTP.get(:_, :_, :_))
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/publisher_test.exs b/test/pleroma/web/activity_pub/publisher_test.exs
	index 97812179b..d993ab1d4 100644
	--- a/test/pleroma/web/activity_pub/publisher_test.exs
	+++ b/test/pleroma/web/activity_pub/publisher_test.exs
	@@ -1,489 +1,490 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.PublisherTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.CommonAPI

	@as_public "https://www.w3.org/ns/activitystreams#Public"

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup_all do
	clear_config([:instance, :federating], true)
	clear_config([:instance, :quarantined_instances], [])
	clear_config([:mrf_simple, :reject], [])
	end

	describe "gather_webfinger_links/1" do
	test "it returns links" do
	user = insert(:user)

	expected_links = [
	%{"href" => user.ap_id, "rel" => "self", "type" => "application/activity+json"},
	%{
	"href" => user.ap_id,
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]

	assert expected_links == Publisher.gather_webfinger_links(user)
	end
	end

	describe "determine_inbox/2" do
	test "it returns sharedInbox for messages involving as:Public in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"to" => [@as_public], "cc" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving as:Public in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"cc" => [@as_public], "to" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"cc" => [], "to" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"to" => [], "cc" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	user_two = insert(:user)

	activity = %Activity{
	data: %{"to" => [user_two.ap_id], "cc" => [user.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns inbox for messages involving single recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	activity = %Activity{
	data: %{"to" => [user.ap_id], "cc" => []}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/personal-inbox"
	end
	end

	describe "publish_one/1" do
	test "publish to url with with different ports" do
	inbox80 = "http://42.site/users/nick1/inbox"
	inbox42 = "http://42.site:42/users/nick1/inbox"

	mock(fn
	%{method: :post, url: "http://42.site:42/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 42"}}

	%{method: :post, url: "http://42.site/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 80"}}
	end)

	actor = insert(:user)

	assert {:ok, %{body: "port 42"}} =
	Publisher.publish_one(%{
	inbox: inbox42,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: true
	})

	assert {:ok, %{body: "port 80"}} =
	Publisher.publish_one(%{
	inbox: inbox80,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: true
	})
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: nil
	})

	refute called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://404.site/users/nick1/inbox"

	assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert capture_log(fn ->
	assert {:error, _} =
	Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
	end) =~ "connrefused"

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	refute called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert capture_log(fn ->
	assert {:error, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})
	end) =~ "connrefused"

	refute called(Instances.set_unreachable(inbox))
	end
	end

	describe "publish/2" do
	test_with_mock "doesn't publish any activity to quarantined or rejected instances.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	Config.put([:instance, :quarantined_instances], [{"domain.com", "some reason"}])

	Config.put([:mrf_simple, :reject], [{"rejected.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox",
	ap_enabled: true
	})

	another_follower =
	insert(:user, %{
	local: false,
	inbox: "https://rejected.com/users/nick2/inbox",
	ap_enabled: true
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	{:ok, _another_follower, actor} = Pleroma.User.follow(another_follower, actor)

	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	public_note_activity =
	insert(:note_activity,
	user: actor,
	recipients: [follower.ap_id, @as_public]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	:ok = Publisher.publish(actor, public_note_activity)

	assert not called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)

	assert not called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: public_note_activity.data["id"]
	})
	)

	assert not called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://rejected.com/users/nick2/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)

	assert not called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://rejected.com/users/nick2/inbox",
	actor_id: actor.id,
	id: public_note_activity.data["id"]
	})
	)
	end

	test_with_mock "Publishes a non-public activity to non-quarantined instances.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	Config.put([:instance, :quarantined_instances], [{"somedomain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox",
	ap_enabled: true
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)
	end

	test_with_mock "publishes an activity with BCC to all relevant peers.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	Config.put([:instance, :quarantined_instances], [])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox",
	ap_enabled: true
	})

	actor = insert(:user, follower_address: follower.ap_id)
	user = insert(:user)

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

	note_activity =
	insert(:note_activity,
	recipients: [follower.ap_id],
	data_attrs: %{"bcc" => [user.ap_id]}
	)

	res = Publisher.publish(actor, note_activity)
	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)
	end

	test_with_mock "publishes a delete activity to peers who signed fetch requests to the create acitvity/object.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	clear_config([:instance, :quarantined_instances], [])

	fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain.com/users/nick1/inbox",
	ap_enabled: true
	)

	another_fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain2.com/users/nick1/inbox",
	ap_enabled: true
	)

	actor = insert(:user)

	note_activity = insert(:note_activity, user: actor)
	object = Object.normalize(note_activity, fetch: false)

	activity_path = String.trim_leading(note_activity.data["id"], Pleroma.Web.Endpoint.url())
	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, fetcher)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, another_fetcher)
	\|> get(activity_path)
	\|> json_response(200)

	{:ok, delete} = CommonAPI.delete(note_activity.id, actor)

	res = Publisher.publish(actor, delete)
	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: delete.data["id"]
	})
	)

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain2.com/users/nick1/inbox",
	actor_id: actor.id,
	id: delete.data["id"]
	})
	)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/relay_test.exs b/test/pleroma/web/activity_pub/relay_test.exs
	index db3291aff..920aef9da 100644
	--- a/test/pleroma/web/activity_pub/relay_test.exs
	+++ b/test/pleroma/web/activity_pub/relay_test.exs
	@@ -1,168 +1,169 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.RelayTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Mock

	test "gets an actor for the relay" do
	user = Relay.get_actor()
	assert user.ap_id == "#{Pleroma.Web.Endpoint.url()}/relay"
	end

	test "relay actor is invisible" do
	user = Relay.get_actor()
	assert User.invisible?(user)
	end

	describe "follow/1" do
	test "returns errors when user not found" do
	assert capture_log(fn ->
	{:error, _} = Relay.follow("test-ap-id")
	end) =~ "Could not decode user at fetch"
	end

	test "returns activity" do
	user = insert(:user)
	service_actor = Relay.get_actor()
	assert {:ok, %Activity{} = activity} = Relay.follow(user.ap_id)
	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["object"] == user.ap_id
	end
	end

	describe "unfollow/1" do
	test "returns errors when user not found" do
	assert capture_log(fn ->
	{:error, _} = Relay.unfollow("test-ap-id")
	end) =~ "Could not decode user at fetch"
	end

	test "returns activity" do
	user = insert(:user)
	service_actor = Relay.get_actor()
	CommonAPI.follow(service_actor, user)
	assert "#{user.ap_id}/followers" in User.following(service_actor)
	assert {:ok, %Activity{} = activity} = Relay.unfollow(user.ap_id)
	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [user.ap_id]
	refute "#{user.ap_id}/followers" in User.following(service_actor)
	end

	test "force unfollow when target service is dead" do
	user = insert(:user)
	user_ap_id = user.ap_id
	user_id = user.id

	Tesla.Mock.mock(fn %{method: :get, url: ^user_ap_id} ->
	%Tesla.Env{status: 404}
	end)

	service_actor = Relay.get_actor()
	CommonAPI.follow(service_actor, user)
	assert "#{user.ap_id}/followers" in User.following(service_actor)

	assert Pleroma.Repo.get_by(
	Pleroma.FollowingRelationship,
	follower_id: service_actor.id,
	following_id: user_id
	)

	Pleroma.Repo.delete(user)
	User.invalidate_cache(user)

	assert {:ok, %Activity{} = activity} = Relay.unfollow(user_ap_id, %{force: true})

	assert refresh_record(service_actor).following_count == 0

	refute Pleroma.Repo.get_by(
	Pleroma.FollowingRelationship,
	follower_id: service_actor.id,
	following_id: user_id
	)

	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [user_ap_id]
	refute "#{user.ap_id}/followers" in User.following(service_actor)
	end
	end

	describe "publish/1" do
	setup do: clear_config([:instance, :federating])

	test "returns error when activity not `Create` type" do
	activity = insert(:like_activity)
	assert Relay.publish(activity) == {:error, "Not implemented"}
	end

	@tag capture_log: true
	test "returns error when activity not public" do
	activity = insert(:direct_note_activity)
	assert Relay.publish(activity) == {:error, false}
	end

	test "returns error when object is unknown" do
	activity =
	insert(:note_activity,
	data: %{
	"type" => "Create",
	"object" => "http://mastodon.example.org/eee/99541947525187367"
	}
	)

	Tesla.Mock.mock(fn
	%{method: :get, url: "http://mastodon.example.org/eee/99541947525187367"} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	assert capture_log(fn ->
	assert Relay.publish(activity) == {:error, false}
	end) =~ "[error] error: false"
	end

	test_with_mock "returns announce activity and publish to federate",
	Pleroma.Web.Federator,
	[:passthrough],
	[] do
	clear_config([:instance, :federating], true)
	service_actor = Relay.get_actor()
	note = insert(:note_activity)
	assert {:ok, %Activity{} = activity} = Relay.publish(note)
	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == service_actor.ap_id
	assert service_actor.follower_address in activity.data["to"]
	assert called(Pleroma.Web.Federator.publish(activity))
	end

	test_with_mock "returns announce activity and not publish to federate",
	Pleroma.Web.Federator,
	[:passthrough],
	[] do
	clear_config([:instance, :federating], false)
	service_actor = Relay.get_actor()
	note = insert(:note_activity)
	assert {:ok, %Activity{} = activity} = Relay.publish(note)
	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == service_actor.ap_id
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/side_effects_test.exs b/test/pleroma/web/activity_pub/side_effects_test.exs
	index 9b1a2296a..80714b1db 100644
	--- a/test/pleroma/web/activity_pub/side_effects_test.exs
	+++ b/test/pleroma/web/activity_pub/side_effects_test.exs
	@@ -1,813 +1,814 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory

	describe "handle" do
	test "it queues a fetch of instance information" do
	author = insert(:user, local: false, ap_id: "https://wowee.example.com/users/1")
	recipient = insert(:user, local: true)

	{:ok, note_data, _meta} =
	Builder.note(%Pleroma.Web.CommonAPI.ActivityDraft{
	user: author,
	to: [recipient.ap_id],
	mentions: [recipient],
	content_html: "hey",
	extra: %{"id" => "https://wowee.example.com/notes/1"}
	})

	{:ok, create_activity_data, _meta} =
	Builder.create(author, note_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: note_data)

	assert_enqueued(
	worker: Pleroma.Workers.NodeInfoFetcherWorker,
	args: %{"op" => "process", "source_url" => "https://wowee.example.com/users/1"}
	)
	end
	end

	describe "handle_after_transaction" do
	test "it streams out notifications and streams" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, note_data, _meta} =
	Builder.note(%Pleroma.Web.CommonAPI.ActivityDraft{
	user: author,
	to: [recipient.ap_id],
	mentions: [recipient],
	content_html: "hey",
	extra: %{"id" => Utils.generate_object_id()}
	})

	{:ok, create_activity_data, _meta} =
	Builder.create(author, note_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: note_data)

	assert [notification] = meta[:notifications]

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	SideEffects.handle_after_transaction(meta)

	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	assert called(Pleroma.Web.Push.send(notification))
	end
	end
	end

	describe "blocking users" do
	setup do
	user = insert(:user)
	blocked = insert(:user)
	User.follow(blocked, user)
	User.follow(user, blocked)

	{:ok, block_data, []} = Builder.block(user, blocked)
	{:ok, block, _meta} = ActivityPub.persist(block_data, local: true)

	%{user: user, blocked: blocked, block: block}
	end

	test "it unfollows and blocks", %{user: user, blocked: blocked, block: block} do
	assert User.following?(user, blocked)
	assert User.following?(blocked, user)

	{:ok, _, _} = SideEffects.handle(block)

	refute User.following?(user, blocked)
	refute User.following?(blocked, user)
	assert User.blocks?(user, blocked)
	end

	test "it updates following relationship", %{user: user, blocked: blocked, block: block} do
	{:ok, _, _} = SideEffects.handle(block)

	refute Pleroma.FollowingRelationship.get(user, blocked)
	assert User.get_follow_state(user, blocked) == nil
	assert User.get_follow_state(blocked, user) == nil
	assert User.get_follow_state(user, blocked, nil) == nil
	assert User.get_follow_state(blocked, user, nil) == nil
	end

	test "it blocks but does not unfollow if the relevant setting is set", %{
	user: user,
	blocked: blocked,
	block: block
	} do
	clear_config([:activitypub, :unfollow_blocked], false)
	assert User.following?(user, blocked)
	assert User.following?(blocked, user)

	{:ok, _, _} = SideEffects.handle(block)

	refute User.following?(user, blocked)
	assert User.following?(blocked, user)
	assert User.blocks?(user, blocked)
	end
	end

	describe "update users" do
	setup do
	user = insert(:user, local: false)

	{:ok, update_data, []} =
	Builder.update(user, %{"id" => user.ap_id, "type" => "Person", "name" => "new name!"})

	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	%{user: user, update_data: update_data, update: update}
	end

	test "it updates the user", %{user: user, update: update} do
	{:ok, _, _} = SideEffects.handle(update)
	user = User.get_by_id(user.id)
	assert user.name == "new name!"
	end

	test "it uses a given changeset to update", %{user: user, update: update} do
	changeset = Ecto.Changeset.change(user, %{default_scope: "direct"})

	assert user.default_scope == "public"
	{:ok, _, _} = SideEffects.handle(update, user_update_changeset: changeset)
	user = User.get_by_id(user.id)
	assert user.default_scope == "direct"
	end
	end

	describe "update notes" do
	setup do
	make_time = fn ->
	Pleroma.Web.ActivityPub.Utils.make_date()
	end

	user = insert(:user)
	note = insert(:note, user: user, data: %{"published" => make_time.()})
	_note_activity = insert(:note_activity, note: note)

	updated_note =
	note.data
	\|> Map.put("summary", "edited summary")
	\|> Map.put("content", "edited content")
	\|> Map.put("updated", make_time.())

	{:ok, update_data, []} = Builder.update(user, updated_note)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	%{
	user: user,
	note: note,
	object_id: note.id,
	update_data: update_data,
	update: update,
	updated_note: updated_note
	}
	end

	test "it updates the note", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	updated_time = updated_note["updated"]

	new_note = Pleroma.Object.get_by_id(object_id)

	assert %{
	"summary" => "edited summary",
	"content" => "edited content",
	"updated" => ^updated_time
	} = new_note.data
	end

	test "it rejects updates with no updated attribute in object", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	updated_note = Map.drop(updated_note, ["updated"])
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it rejects updates with updated attribute older than what we have in the original object",
	%{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, creation_time, _} = DateTime.from_iso8601(old_note.data["published"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(creation_time, -10)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it rejects updates with updated attribute older than the last Update", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, creation_time, _} = DateTime.from_iso8601(old_note.data["published"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(creation_time, +10)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)

	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, update_time, _} = DateTime.from_iso8601(old_note.data["updated"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(update_time, -5)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)

	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it updates using object_data", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	updated_note = Map.put(updated_note, "summary", "mew mew")
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "mew mew", "content" => "edited content"} = new_note.data
	end

	test "it records the original note in formerRepresentations", %{
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary", "content" => "edited content"} = new_note

	assert [Map.drop(note.data, ["id", "formerRepresentations"])] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 1
	end

	test "it puts the original note at the front of formerRepresentations", %{
	user: user,
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: first_edit} = Pleroma.Object.get_by_id(object_id)

	second_updated_note =
	note.data
	\|> Map.put("summary", "edited summary 2")
	\|> Map.put("content", "edited content 2")
	\|> Map.put(
	"updated",
	first_edit["updated"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> DateTime.add(10)
	\|> DateTime.to_iso8601()
	)

	{:ok, second_update_data, []} = Builder.update(user, second_updated_note)
	{:ok, update, _meta} = ActivityPub.persist(second_update_data, local: true)
	{:ok, _, _} = SideEffects.handle(update, object_data: second_updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary 2", "content" => "edited content 2"} = new_note

	original_version = Map.drop(note.data, ["id", "formerRepresentations"])
	first_edit = Map.drop(first_edit, ["id", "formerRepresentations"])

	assert [first_edit, original_version] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 2
	end

	test "it does not prepend to formerRepresentations if no actual changes are made", %{
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: first_edit} = Pleroma.Object.get_by_id(object_id)

	updated_note =
	updated_note
	\|> Map.put(
	"updated",
	first_edit["updated"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> DateTime.add(10)
	\|> DateTime.to_iso8601()
	)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary", "content" => "edited content"} = new_note

	original_version = Map.drop(note.data, ["id", "formerRepresentations"])

	assert [original_version] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 1
	end
	end

	describe "update questions" do
	setup do
	user = insert(:user)

	question =
	insert(:question,
	user: user,
	data: %{"published" => Pleroma.Web.ActivityPub.Utils.make_date()}
	)

	%{user: user, data: question.data, id: question.id}
	end

	test "allows updating choice count without generating edit history", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)
	\|> Map.put("updated", Pleroma.Web.ActivityPub.Utils.make_date())

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end

	test "allows updating choice count without updated field", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end

	test "allows updating choice count with updated field same as the creation date", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)
	\|> Map.put("updated", data["published"])

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end
	end

	describe "EmojiReact objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
	{:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)

	%{emoji_react: emoji_react, user: user, poster: poster}
	end

	test "adds the reaction to the object", %{emoji_react: emoji_react, user: user} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	object = Object.get_by_ap_id(emoji_react.data["object"])

	assert object.data["reaction_count"] == 1
	assert ["👌", [user.ap_id], nil] in object.data["reactions"]
	end

	test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: emoji_react.id)
	end
	end

	describe "Question objects" do
	setup do
	user = insert(:user)
	question = build(:question, user: user)
	question_activity = build(:question_activity, question: question)
	activity_data = Map.put(question_activity.data, "object", question.data["id"])
	meta = [object_data: question.data, local: false]

	{:ok, activity, meta} = ActivityPub.persist(activity_data, meta)

	%{activity: activity, meta: meta}
	end

	test "enqueues the poll end", %{activity: activity, meta: meta} do
	{:ok, activity, meta} = SideEffects.handle(activity, meta)

	{:ok, time, _} = DateTime.from_iso8601(meta[:object_data]["closed"])

	assert_enqueued(
	worker: Pleroma.Workers.PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: time
	)
	end
	end

	describe "delete users with confirmation pending" do
	setup do
	user = insert(:user, is_confirmed: false)
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
	{:ok, delete: delete_user, user: user}
	end

	test "when activation is required", %{delete: delete, user: user} do
	clear_config([:instance, :account_activation_required], true)
	{:ok, _, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	refute User.get_cached_by_id(user.id)
	end
	end

	describe "Undo objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, like} = CommonAPI.favorite(user, post.id)
	{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
	{:ok, announce} = CommonAPI.repeat(post.id, user)
	{:ok, block} = CommonAPI.block(user, poster)

	{:ok, undo_data, _meta} = Builder.undo(user, like)
	{:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, reaction)
	{:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, announce)
	{:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, block)
	{:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	%{
	like_undo: like_undo,
	post: post,
	like: like,
	reaction_undo: reaction_undo,
	reaction: reaction,
	announce_undo: announce_undo,
	announce: announce,
	block_undo: block_undo,
	block: block,
	poster: poster,
	user: user
	}
	end

	test "deletes the original block", %{
	block_undo: block_undo,
	block: block
	} do
	{:ok, _block_undo, _meta} = SideEffects.handle(block_undo)

	refute Activity.get_by_id(block.id)
	end

	test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
	blocker = User.get_by_ap_id(block.data["actor"])
	blocked = User.get_by_ap_id(block.data["object"])

	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute User.blocks?(blocker, blocked)
	end

	test "an announce undo removes the announce from the object", %{
	announce_undo: announce_undo,
	post: post
	} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["announcement_count"] == 0
	assert object.data["announcements"] == []
	end

	test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
	refute Activity.get_by_id(announce.id)
	end

	test "a reaction undo removes the reaction from the object", %{
	reaction_undo: reaction_undo,
	post: post
	} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["reaction_count"] == 0
	assert object.data["reactions"] == []
	end

	test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
	refute Activity.get_by_id(reaction.id)
	end

	test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["like_count"] == 0
	assert object.data["likes"] == []
	end

	test "deletes the original like", %{like_undo: like_undo, like: like} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)
	refute Activity.get_by_id(like.id)
	end
	end

	describe "like objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, like_data, _meta} = Builder.like(user, post.object)
	{:ok, like, _meta} = ActivityPub.persist(like_data, local: true)

	%{like: like, user: user, poster: poster}
	end

	test "add the like to the original object", %{like: like, user: user} do
	{:ok, like, _} = SideEffects.handle(like)
	object = Object.get_by_ap_id(like.data["object"])
	assert object.data["like_count"] == 1
	assert user.ap_id in object.data["likes"]
	end

	test "creates a notification", %{like: like, poster: poster} do
	{:ok, like, _} = SideEffects.handle(like)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
	end
	end

	describe "announce objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, private_post} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, announce_data, _meta} = Builder.announce(user, post.object, public: true)

	{:ok, private_announce_data, _meta} =
	Builder.announce(user, private_post.object, public: false)

	{:ok, relay_announce_data, _meta} =
	Builder.announce(Pleroma.Web.ActivityPub.Relay.get_actor(), post.object, public: true)

	{:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)
	{:ok, private_announce, _meta} = ActivityPub.persist(private_announce_data, local: true)
	{:ok, relay_announce, _meta} = ActivityPub.persist(relay_announce_data, local: true)

	%{
	announce: announce,
	user: user,
	poster: poster,
	private_announce: private_announce,
	relay_announce: relay_announce
	}
	end

	test "adds the announce to the original object", %{announce: announce, user: user} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == 1
	assert user.ap_id in object.data["announcements"]
	end

	test "does not add the announce to the original object if the actor is a service actor", %{
	relay_announce: announce
	} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == nil
	end

	test "creates a notification", %{announce: announce, poster: poster} do
	{:ok, announce, _} = SideEffects.handle(announce)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: announce.id)
	end

	test "it streams out the announce", %{announce: announce} do
	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, announce, _} = SideEffects.handle(announce)

	assert called(Pleroma.Web.Streamer.stream(["user", "list"], announce))

	assert called(Pleroma.Web.Push.send(:_))
	end
	end
	end

	describe "removing a follower" do
	setup do
	user = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(user, followed)

	{:ok, reject_data, []} = Builder.reject(followed, follow_activity)
	{:ok, reject, _meta} = ActivityPub.persist(reject_data, local: true)

	%{user: user, followed: followed, reject: reject}
	end

	test "", %{user: user, followed: followed, reject: reject} do
	assert User.following?(user, followed)
	assert Pleroma.FollowingRelationship.get(user, followed)

	{:ok, _, _} = SideEffects.handle(reject)

	refute User.following?(user, followed)
	refute Pleroma.FollowingRelationship.get(user, followed)
	assert User.get_follow_state(user, followed) == nil
	assert User.get_follow_state(user, followed, nil) == nil
	end
	end

	describe "removing a follower from remote" do
	setup do
	user = insert(:user)
	followed = insert(:user, local: false)

	# Mock a local-to-remote follow
	{:ok, follow_data, []} = Builder.follow(user, followed)

	follow_data =
	follow_data
	\|> Map.put("state", "accept")

	{:ok, follow, _meta} = ActivityPub.persist(follow_data, local: true)
	{:ok, _, _} = SideEffects.handle(follow)

	# Mock a remote-to-local accept
	{:ok, accept_data, _} = Builder.accept(followed, follow)
	{:ok, accept, _} = ActivityPub.persist(accept_data, local: false)
	{:ok, _, _} = SideEffects.handle(accept)

	# Mock a remote-to-local reject
	{:ok, reject_data, []} = Builder.reject(followed, follow)
	{:ok, reject, _meta} = ActivityPub.persist(reject_data, local: false)

	%{user: user, followed: followed, reject: reject}
	end

	test "", %{user: user, followed: followed, reject: reject} do
	assert User.following?(user, followed)
	assert Pleroma.FollowingRelationship.get(user, followed)

	{:ok, _, _} = SideEffects.handle(reject)

	refute User.following?(user, followed)
	refute Pleroma.FollowingRelationship.get(user, followed)

	assert Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, followed).data["state"] ==
	"reject"

	assert User.get_follow_state(user, followed) == nil
	assert User.get_follow_state(user, followed, nil) == nil
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
	index 4caf18435..33b9657d5 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
	@@ -1,208 +1,209 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.FollowHandlingTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Factory
	import Ecto.Query
	import Mock

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

	describe "handle_incoming" do
	setup do: clear_config([:user, :deny_follow_blocked])

	test "it works for osada follow request" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/osada-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://apfed.club/channel/indio"
	assert data["type"] == "Follow"
	assert data["id"] == "https://apfed.club/follow/9"

	activity = Repo.get(Activity, activity.id)
	assert activity.data["state"] == "accept"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follow requests" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Follow"
	assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"

	activity = Repo.get(Activity, activity.id)
	assert activity.data["state"] == "accept"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)

	[notification] = Notification.for_user(user)
	assert notification.type == "follow"
	end

	test "with locked accounts, it does create a Follow, but not an Accept" do
	user = insert(:user, is_locked: true)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["state"] == "pending"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)

	accepts =
	from(
	a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Accept")
	)
	\|> Repo.all()

	assert Enum.empty?(accepts)

	[notification] = Notification.for_user(user)
	assert notification.type == "follow_request"
	end

	test "it works for follow requests when you are already followed, creating a new accept activity" do
	# This is important because the remote might have the wrong idea about the
	# current follow status. This can lead to instance A thinking that x@A is
	# followed by y@B, but B thinks they are not. In this case, the follow can
	# never go through again because it will never get an Accept.
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)

	accepts =
	from(
	a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Accept")
	)
	\|> Repo.all()

	assert length(accepts) == 1

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("id", String.replace(data["id"], "2", "3"))
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)

	accepts =
	from(
	a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Accept")
	)
	\|> Repo.all()

	assert length(accepts) == 2
	end

	test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do
	clear_config([:user, :deny_follow_blocked], true)

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

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

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)

	%Activity{} = activity = Activity.get_by_ap_id(id)

	assert activity.data["state"] == "reject"
	end

	test "it rejects incoming follow requests if the following errors for some reason" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	with_mock Pleroma.User, [:passthrough], follow: fn _, _, _ -> {:error, :testing} end do
	{:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)

	%Activity{} = activity = Activity.get_by_ap_id(id)

	assert activity.data["state"] == "reject"
	end
	end

	test "it works for incoming follow requests from hubzilla" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/hubzilla-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Utils.normalize_params()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
	assert data["type"] == "Follow"
	assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follows to locked account" do
	pending_follower = insert(:user, ap_id: "http://mastodon.example.org/users/admin")
	user = insert(:user, is_locked: true)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Follow"
	assert data["object"] == user.ap_id
	assert data["state"] == "pending"
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	assert [^pending_follower] = User.get_follow_requests(user)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	index f465b5cd1..16ee31483 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	@@ -1,824 +1,825 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory

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

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

	describe "handle_incoming" do
	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert "test" in Object.tags(object)
	assert Object.hashtags(object) == ["test"]
	end

	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", Object.normalize(activity, fetch: false).data)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	@tag capture_log: true
	test "it fetches reply-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://mstdn.io/users/mayuutann/statuses/99568293732299394")

	data = Map.put(data, "object", object)
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)
	returned_object = Object.normalize(returned_activity, fetch: false)

	assert %Activity{} =
	Activity.get_create_by_object_ap_id(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)

	assert returned_object.data["inReplyTo"] ==
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	end

	test "it does not fetch reply-to activities beyond max replies depth limit" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data = Map.put(data, "object", object)

	with_mock Pleroma.Web.Federator,
	allowed_thread_distance?: fn _ -> false end do
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	returned_object = Object.normalize(returned_activity, fetch: false)

	refute Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_object.data["inReplyTo"] == "https://shitposter.club/notice/2827873"
	end
	end

	test "it does not crash if the object in inReplyTo can't be fetched" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://404.site/whatever")

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

	assert {:ok, _returned_activity} = Transmogrifier.handle_incoming(data)
	end

	test "it does not work for deactivated users" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	insert(:user, ap_id: data["actor"], is_active: false)

	assert {:error, _} = Transmogrifier.handle_incoming(data)
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://localtesting.pleroma.lol/users/lain",
	"http://mastodon.example.org/users/admin/followers"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object_data = Object.normalize(data["object"], fetch: false).data

	assert object_data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object_data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object_data["cc"] == [
	"http://localtesting.pleroma.lol/users/lain",
	"http://mastodon.example.org/users/admin/followers"
	]

	assert object_data["actor"] == "http://mastodon.example.org/users/admin"
	assert object_data["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object_data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object_data["sensitive"] == true

	user = User.get_cached_by_ap_id(object_data["actor"])

	assert user.note_count == 1
	end

	test "it works for incoming notices without the sensitive property but an nsfw hashtag" do
	data = File.read!("test/fixtures/mastodon-post-activity-nsfw.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	object_data = Object.normalize(data["object"], fetch: false).data

	assert object_data["sensitive"] == true
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert match?(
	%{
	"href" => "http://localtesting.pleroma.lol/users/lain",
	"name" => "@lain@localtesting.pleroma.lol",
	"type" => "Mention"
	},
	Enum.at(object.data["tag"], 0)
	)

	assert match?(
	%{
	"href" => "http://mastodon.example.org/tags/moo",
	"name" => "#moo",
	"type" => "Hashtag"
	},
	Enum.at(object.data["tag"], 1)
	)

	assert "moo" == Enum.at(object.data["tag"], 2)
	end

	test "it works for incoming notices with contentMap" do
	data = File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Jason.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"], fetch: false)

	assert object.data["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

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

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("cc", nil)
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	refute is_nil(data["cc"])
	end

	test "it strips internal likes" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	likes = %{
	"first" =>
	"http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
	"id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
	"totalItems" => 3,
	"type" => "OrderedCollection"
	}

	object = Map.put(data["object"], "likes", likes)
	data = Map.put(data, "object", object)

	{:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity)

	assert object.data["likes"] == []
	end

	test "it strips internal reactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "📢")

	%{object: object} = Activity.get_by_id_with_object(activity.id)
	assert Map.has_key?(object.data, "reactions")
	assert Map.has_key?(object.data, "reaction_count")

	object_data = Transmogrifier.strip_internal_fields(object.data)
	refute Map.has_key?(object_data, "reactions")
	refute Map.has_key?(object_data, "reaction_count")
	end

	test "it correctly processes messages with non-array to field" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("to", "https://www.w3.org/ns/activitystreams#Public")
	\|> put_in(["object", "to"], "https://www.w3.org/ns/activitystreams#Public")

	assert {:ok, activity} = Transmogrifier.handle_incoming(data)

	assert [
	"http://localtesting.pleroma.lol/users/lain",
	"http://mastodon.example.org/users/admin/followers"
	] == activity.data["cc"]

	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with non-array cc field" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("cc", "http://mastodon.example.org/users/admin/followers")
	\|> put_in(["object", "cc"], "http://mastodon.example.org/users/admin/followers")

	assert {:ok, activity} = Transmogrifier.handle_incoming(data)

	assert ["http://mastodon.example.org/users/admin/followers"] == activity.data["cc"]
	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with weirdness in address fields" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("cc", ["http://mastodon.example.org/users/admin/followers", ["¿"]])
	\|> put_in(["object", "cc"], ["http://mastodon.example.org/users/admin/followers", ["¿"]])

	assert {:ok, activity} = Transmogrifier.handle_incoming(data)

	assert ["http://mastodon.example.org/users/admin/followers"] == activity.data["cc"]
	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end
	end

	describe "`handle_incoming/2`, Mastodon format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

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

	items = get_in(data, ["object", "replies", "first", "items"])
	assert length(items) > 0

	%{data: data, items: items}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	data: data,
	items: items
	} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 10)

	{:ok, activity} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(activity.data["object"])

	assert object.data["replies"] == items

	for id <- items do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{data: data} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	{:ok, _activity} = Transmogrifier.handle_incoming(data)

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "`handle_incoming/2`, Pleroma format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	replies = %{
	"type" => "Collection",
	"items" => [Utils.generate_object_id(), Utils.generate_object_id()]
	}

	activity =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Kernel.put_in(["object", "replies"], replies)

	%{activity: activity}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	activity: activity
	} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 1)

	assert {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(data["object"])

	for id <- object.data["replies"] do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{activity: activity} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	{:ok, _activity} = Transmogrifier.handle_incoming(activity)

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end

	describe "fix_in_reply_to/2" do
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	[data: data]
	end

	test "returns not modified object when hasn't containts inReplyTo field", %{data: data} do
	assert Transmogrifier.fix_in_reply_to(data) == data
	end

	test "returns object with inReplyTo when denied incoming reply", %{data: data} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	object_with_reply =
	Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873")

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == "https://shitposter.club/notice/2827873"

	object_with_reply =
	Map.put(data["object"], "inReplyTo", %{"id" => "https://shitposter.club/notice/2827873"})

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == %{"id" => "https://shitposter.club/notice/2827873"}

	object_with_reply =
	Map.put(data["object"], "inReplyTo", ["https://shitposter.club/notice/2827873"])

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == ["https://shitposter.club/notice/2827873"]

	object_with_reply = Map.put(data["object"], "inReplyTo", [])
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == []
	end

	@tag capture_log: true
	test "returns modified object when allowed incoming reply", %{data: data} do
	object_with_reply =
	Map.put(
	data["object"],
	"inReplyTo",
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)

	clear_config([:instance, :federation_incoming_replies_max_depth], 5)
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)

	assert modified_object["inReplyTo"] ==
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"

	assert modified_object["context"] ==
	"tag:shitposter.club,2018-02-22:objectType=thread:nonce=e5a7c72d60a9c0e4"
	end
	end

	describe "fix_attachments/1" do
	test "returns not modified object" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_attachments(data) == data
	end

	test "returns modified object when attachment is map" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => %{
	"mediaType" => "video/mp4",
	"url" => "https://peertube.moe/stat-480.mp4"
	}
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"type" => "Document",
	"url" => [
	%{
	"href" => "https://peertube.moe/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end

	test "returns modified object when attachment is list" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => [
	%{"mediaType" => "video/mp4", "url" => "https://pe.er/stat-480.mp4"},
	%{"mimeType" => "video/mp4", "href" => "https://pe.er/stat-480.mp4"}
	]
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"type" => "Document",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	},
	%{
	"mediaType" => "video/mp4",
	"type" => "Document",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end
	end

	describe "fix_emoji/1" do
	test "returns not modified object when object not contains tags" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_emoji(data) == data
	end

	test "returns object with emoji when object contains list tags" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => [
	%{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}},
	%{"type" => "Hashtag"}
	]
	}) == %{
	"emoji" => %{"bib" => "/test"},
	"tag" => [
	%{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"},
	%{"type" => "Hashtag"}
	]
	}
	end

	test "returns object with emoji when object contains map tag" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}}
	}) == %{
	"emoji" => %{"bib" => "/test"},
	"tag" => %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"}
	}
	end
	end

	describe "set_replies/1" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 2)

	test "returns unmodified object if activity doesn't have self-replies" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.set_replies(data) == data
	end

	test "sets `replies` collection with a limited number of self-replies" do
	[user, another_user] = insert_list(2, :user)

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

	{:ok, %{id: id2} = self_reply1} =
	CommonAPI.post(user, %{status: "self-reply 1", in_reply_to_status_id: id1})

	{:ok, self_reply2} =
	CommonAPI.post(user, %{status: "self-reply 2", in_reply_to_status_id: id1})

	# Assuming to _not_ be present in `replies` due to :note_replies_output_limit is set to 2
	{:ok, _} = CommonAPI.post(user, %{status: "self-reply 3", in_reply_to_status_id: id1})

	{:ok, _} =
	CommonAPI.post(user, %{
	status: "self-reply to self-reply",
	in_reply_to_status_id: id2
	})

	{:ok, _} =
	CommonAPI.post(another_user, %{
	status: "another user's reply",
	in_reply_to_status_id: id1
	})

	object = Object.normalize(activity, fetch: false)
	replies_uris = Enum.map([self_reply1, self_reply2], fn a -> a.object.data["id"] end)

	assert %{"type" => "Collection", "items" => ^replies_uris} =
	Transmogrifier.set_replies(object.data)["replies"]
	end
	end

	test "take_emoji_tags/1" do
	user = insert(:user, %{emoji: %{"firefox" => "https://example.org/firefox.png"}})

	assert Transmogrifier.take_emoji_tags(user) == [
	%{
	"icon" => %{"type" => "Image", "url" => "https://example.org/firefox.png"},
	"id" => "https://example.org/firefox.png",
	"name" => ":firefox:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	end

	describe "fix_quote_url/1" do
	test "a misskey quote should work", _ do
	Tesla.Mock.mock(fn %{
	method: :get,
	url: "https://example.com/objects/43479e20-c0f8-4f49-bf7f-13fab8234924"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/quoted_status.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}
	end)

	insert(:user, %{ap_id: "https://misskey.io/users/93492q0ip0"})
	insert(:user, %{ap_id: "https://example.com/users/user"})

	note =
	"test/fixtures/misskey/quote.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{"quoteUri" => "https://example.com/objects/43479e20-c0f8-4f49-bf7f-13fab8234924"} =
	Transmogrifier.fix_quote_url(note)
	end

	test "a fedibird quote should work", _ do
	Tesla.Mock.mock(fn %{
	method: :get,
	url: "https://example.com/objects/43479e20-c0f8-4f49-bf7f-13fab8234924"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/quoted_status.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}
	end)

	insert(:user, %{ap_id: "https://fedibird.com/users/akkoma_ap_integration_tester"})
	insert(:user, %{ap_id: "https://example.com/users/user"})

	note =
	"test/fixtures/fedibird/quote.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{
	"quoteUri" => "https://example.com/objects/43479e20-c0f8-4f49-bf7f-13fab8234924"
	} = Transmogrifier.fix_quote_url(note)
	end

	test "quote fetching should stop after n levels", _ do
	clear_config([:instance, :federation_incoming_replies_max_depth], 1)

	Tesla.Mock.mock(fn %{
	method: :get,
	url: "https://misskey.io/notes/934gok3482"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/misskey/recursive_quote.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}
	end)

	insert(:user, %{ap_id: "https://misskey.io/users/93492q0ip0"})

	note =
	"test/fixtures/misskey/recursive_quote.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{
	"quoteUri" => "https://misskey.io/notes/934gok3482"
	} = Transmogrifier.fix_quote_url(note)
	end
	end

	test "the standalone note uses its own ID when context is missing" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")

	activity =
	"test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	{:ok, %Activity{} = modified} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(modified, fetch: false)

	assert object.data["context"] == object.data["id"]
	assert modified.data["context"] == object.data["id"]
	end

	test "the reply note uses its parent's ID when context is missing and reply is unreachable" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")

	activity =
	"test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	object =
	activity["object"]
	\|> Map.put("inReplyTo", "https://404.site/object/went-to-buy-milk")

	activity =
	activity
	\|> Map.put("object", object)

	{:ok, %Activity{} = modified} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(modified, fetch: false)

	assert object.data["context"] == object.data["inReplyTo"]
	assert modified.data["context"] == object.data["inReplyTo"]
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index 62472231b..e473ae659 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,629 +1,629 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false
	-
	+ @moduletag :mocked
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

	setup do: clear_config([:instance, :max_remote_account_fields])
	setup do: clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	describe "handle_incoming" do
	test "it works for incoming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})
	object = Object.normalize(activity, fetch: false)

	note_obj = %{
	"type" => "Note",
	"id" => activity.data["id"],
	"content" => "test post",
	"published" => object.data["published"],
	"actor" => AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	}

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, activity.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	assert activity.data["object"] == [user.ap_id, note_obj]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it accepts Move activities" do
	old_user = insert(:user)
	new_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Move",
	"actor" => old_user.ap_id,
	"object" => old_user.ap_id,
	"target" => new_user.ap_id
	}

	assert :error = Transmogrifier.handle_incoming(message)

	{:ok, _new_user} = User.update_and_set_cache(new_user, %{also_known_as: [old_user.ap_id]})

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(message)
	assert activity.actor == old_user.ap_id
	assert activity.data["actor"] == old_user.ap_id
	assert activity.data["object"] == old_user.ap_id
	assert activity.data["target"] == new_user.ap_id
	assert activity.data["type"] == "Move"
	end

	test "it fixes both the Create and object contexts in a reply" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")
	insert(:user, ap_id: "https://p.helene.moe/users/helene")

	create_activity =
	"test/fixtures/create-pleroma-reply-to-misskey-thread.json"
	\|> File.read!()
	\|> Jason.decode!()

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(create_activity)

	object = Object.normalize(activity, fetch: false)

	assert activity.data["context"] == object.data["context"]
	end
	end

	describe "prepare outgoing" do
	test "it inlines private announced objects" do
	user = insert(:user)

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

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)

	{:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)

	assert modified["object"]["content"] == "hey"
	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})

	with_mock Pleroma.Notification,
	get_notified_from_activity: fn _, _ -> [] end do
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	refute called(Pleroma.Notification.get_notified_from_activity(:_, :_))
	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] == Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

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

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "#2hu :firefox:",
	generator: %{type: "Application", name: "TestClient", url: "https://pleroma.social"}
	})

	# Ensure injected application data made it into the activity
	# as we don't have a Token to derive it from, otherwise it will
	# be nil and the test will pass
	assert %{
	type: "Application",
	name: "TestClient",
	url: "https://pleroma.social"
	} == activity.object.data["generator"]

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["generator"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["likes"])
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} :moominmamma:",
	visibility: "direct"
	})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert is_nil(modified["bcc"])
	end

	test "custom emoji urls are URI encoded" do
	# :dinosaur: filename has a space -> dino walking.gif
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(prepared["object"]["tag"]) == 1

	url = prepared["object"]["tag"] \|> List.first() \|> Map.get("icon") \|> Map.get("url")

	assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	end

	test "Updates of Notes are handled" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})
	{:ok, update} = CommonAPI.update(user, activity, %{status: "mew mew :blank:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(update.data)

	assert %{
	"content" => "mew mew :blank:",
	"tag" => [%{"name" => ":blank:", "type" => "Emoji"}],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"content" => "everybody do the dinosaur :dinosaur:",
	"tag" => [%{"name" => ":dinosaur:", "type" => "Emoji"}]
	}
	]
	}
	} = prepared["object"]
	end
	end

	describe "user upgrade" do
	test "it upgrades a user to activitypub" do
	user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	user_two = insert(:user)
	Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept)

	{:ok, activity} = CommonAPI.post(user, %{status: "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{status: "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	ObanHelpers.perform_all()

	assert user.ap_enabled
	assert user.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"
	assert user.following_address == "https://niu.moe/users/rye/following"

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 1

	activity = Activity.get_by_id(activity.id)
	assert user.follower_address in activity.recipients

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]
	} = user.avatar

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]
	} = user.banner

	refute "..." in activity.recipients

	unrelated_activity = Activity.get_by_id(unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = User.get_cached_by_id(user_two.id)
	assert User.following?(user_two, user)
	refute "..." in User.following(user_two)
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end

	describe "fix_summary/1" do
	test "returns fixed object" do
	assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
	assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
	assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
	end
	end

	describe "fix_url/1" do
	test "fixes data for object when url is map" do
	object = %{
	"url" => %{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	}

	assert Transmogrifier.fix_url(object) == %{
	"url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	end

	test "returns non-modified object" do
	assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
	end
	end

	describe "get_obj_helper/2" do
	test "returns nil when cannot normalize object" do
	assert capture_log(fn ->
	refute Transmogrifier.get_obj_helper("test-obj-id")
	- end) =~ "Unsupported URI scheme"
	+ end) =~ "URI Scheme Invalid"
	end

	@tag capture_log: true
	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)
	end
	end

	describe "fix_attachments/1" do
	test "puts dimensions into attachment url field" do
	object = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960,
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	expected = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpeg",
	"href" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960
	}
	],
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	assert Transmogrifier.fix_attachments(object) == expected
	end
	end

	describe "prepare_object/1" do
	test "it processes history" do
	original = %{
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)

	history_item = Enum.at(processed["formerRepresentations"]["orderedItems"], 0)

	refute Map.has_key?(history_item, "generator")

	assert [%{"name" => ":blobcat:"}] = history_item["tag"]
	end

	test "it works when there is no or bad history" do
	original = %{
	"formerRepresentations" => %{
	"items" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)
	assert processed["formerRepresentations"] == original["formerRepresentations"]
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs b/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
	index 5842c37d4..82faa6162 100644
	--- a/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
	@@ -1,168 +1,169 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.MediaProxyCacheControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import Pleroma.Factory
	import Mock

	alias Pleroma.Web.MediaProxy

	setup do: clear_config([:media_proxy])

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_proxy, :invalidation, :enabled], true)
	clear_config([:media_proxy, :invalidation, :provider], MediaProxy.Invalidation.Script)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/v1/pleroma/admin/media_proxy_caches" do
	test "shows banned MediaProxy URLs", %{conn: conn} do
	MediaProxy.put_in_banned_urls([
	"http://localhost:4001/media/a688346.jpg",
	"http://localhost:4001/media/fb1f4d.jpg"
	])

	MediaProxy.put_in_banned_urls("http://localhost:4001/media/gb1f44.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/tb13f47.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/wb1f46.jpg")

	response =
	conn
	\|> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2")
	\|> json_response_and_validate_schema(200)

	assert response["page_size"] == 2
	assert response["count"] == 5

	results = response["urls"]

	response =
	conn
	\|> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2&page=2")
	\|> json_response_and_validate_schema(200)

	assert response["page_size"] == 2
	assert response["count"] == 5

	results = results ++ response["urls"]

	response =
	conn
	\|> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2&page=3")
	\|> json_response_and_validate_schema(200)

	results = results ++ response["urls"]

	assert results \|> Enum.sort() ==
	[
	"http://localhost:4001/media/wb1f46.jpg",
	"http://localhost:4001/media/gb1f44.jpg",
	"http://localhost:4001/media/tb13f47.jpg",
	"http://localhost:4001/media/fb1f4d.jpg",
	"http://localhost:4001/media/a688346.jpg"
	]
	\|> Enum.sort()
	end

	test "search banned MediaProxy URLs", %{conn: conn} do
	MediaProxy.put_in_banned_urls([
	"http://localhost:4001/media/a688346.jpg",
	"http://localhost:4001/media/ff44b1f4d.jpg"
	])

	MediaProxy.put_in_banned_urls("http://localhost:4001/media/gb1f44.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/tb13f47.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/wb1f46.jpg")

	response =
	conn
	\|> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2&query=F44")
	\|> json_response_and_validate_schema(200)

	assert response["urls"] \|> Enum.sort() == [
	"http://localhost:4001/media/ff44b1f4d.jpg",
	"http://localhost:4001/media/gb1f44.jpg"
	]

	assert response["page_size"] == 2
	assert response["count"] == 2
	end
	end

	describe "POST /api/v1/pleroma/admin/media_proxy_caches/delete" do
	test "deleted MediaProxy URLs from banned", %{conn: conn} do
	MediaProxy.put_in_banned_urls([
	"http://localhost:4001/media/a688346.jpg",
	"http://localhost:4001/media/fb1f4d.jpg"
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/media_proxy_caches/delete", %{
	urls: ["http://localhost:4001/media/a688346.jpg"]
	})
	\|> json_response_and_validate_schema(200)

	refute MediaProxy.in_banned_urls("http://localhost:4001/media/a688346.jpg")
	assert MediaProxy.in_banned_urls("http://localhost:4001/media/fb1f4d.jpg")
	end
	end

	describe "POST /api/v1/pleroma/admin/media_proxy_caches/purge" do
	test "perform invalidates cache of MediaProxy", %{conn: conn} do
	urls = [
	"http://example.com/media/a688346.jpg",
	"http://example.com/media/fb1f4d.jpg"
	]

	with_mocks [
	{MediaProxy.Invalidation.Script, [],
	[
	purge: fn _, _ -> {"ok", 0} end
	]}
	] do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/media_proxy_caches/purge", %{urls: urls, ban: false})
	\|> json_response_and_validate_schema(200)

	refute MediaProxy.in_banned_urls("http://example.com/media/a688346.jpg")
	refute MediaProxy.in_banned_urls("http://example.com/media/fb1f4d.jpg")
	end
	end

	test "perform invalidates cache of MediaProxy and adds url to banned", %{conn: conn} do
	urls = [
	"http://example.com/media/a688346.jpg",
	"http://example.com/media/fb1f4d.jpg"
	]

	with_mocks [{MediaProxy.Invalidation.Script, [], [purge: fn _, _ -> {"ok", 0} end]}] do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/v1/pleroma/admin/media_proxy_caches/purge",
	%{urls: urls, ban: true}
	)
	\|> json_response_and_validate_schema(200)

	assert MediaProxy.in_banned_urls("http://example.com/media/a688346.jpg")
	assert MediaProxy.in_banned_urls("http://example.com/media/fb1f4d.jpg")
	end
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/user_controller_test.exs b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	index 6e99fb2ba..ba6465630 100644
	--- a/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	@@ -1,971 +1,972 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.UserControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.HTML
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

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

	:ok
	end

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	user = insert(:user)

	conn =
	get(build_conn(), "/api/v1/pleroma/admin/users/#{user.nickname}?admin_token=password123")

	assert json_response_and_validate_schema(conn, 200)
	end

	test "GET /api/v1/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/v1/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response_and_validate_schema(conn, 200)
	end

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response_and_validate_schema(conn, :forbidden)
	end
	end

	describe "DELETE /api/v1/pleroma/admin/users" do
	test "single user", %{admin: admin, conn: conn} do
	clear_config([:instance, :federating], true)

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	banner: %{"url" => [%{"href" => "https://somebanner"}]},
	bio: "Hello world!",
	name: "A guy"
	)

	# Create some activities to check they got deleted later
	follower = insert(:user)
	{:ok, _} = CommonAPI.post(user, %{status: "test"})
	{:ok, _, _, _} = CommonAPI.follow(user, follower)
	{:ok, _, _, _} = CommonAPI.follow(follower, user)
	user = Repo.get(User, user.id)
	assert user.note_count == 1
	assert user.follower_count == 1
	assert user.following_count == 1
	assert user.is_active

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end,
	perform: fn _, _ -> nil end do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/v1/pleroma/admin/users?nickname=#{user.nickname}")

	ObanHelpers.perform_all()

	refute User.get_by_nickname(user.nickname).is_active

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user.nickname}"

	assert json_response_and_validate_schema(conn, 200) == [user.nickname]

	user = Repo.get(User, user.id)
	refute user.is_active

	assert user.avatar == %{}
	assert user.banner == %{}
	assert user.note_count == 0
	assert user.follower_count == 0
	assert user.following_count == 0
	assert user.bio == ""
	assert user.name == nil

	assert called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "multiple users", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/pleroma/admin/users", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})
	\|> json_response_and_validate_schema(200)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"

	assert response -- [user_one.nickname, user_two.nickname] == []
	end
	end

	describe "/api/v1/pleroma/admin/users" do
	test "Create", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	},
	%{
	"nickname" => "lain2",
	"email" => "lain2@example.org",
	"password" => "test"
	}
	]
	})
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(&Map.get(&1, "type"))

	assert response == ["success", "success"]

	log_entry = Repo.one(ModerationLog)

	assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
	end

	test "Cannot create user with existing email", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	}
	]
	end

	test "Cannot create user with existing nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => user.nickname,
	"email" => "someuser@plerama.social",
	"password" => "test"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => "someuser@plerama.social",
	"nickname" => user.nickname
	},
	"error" => "nickname has already been taken",
	"type" => "error"
	}
	]
	end

	test "Multiple user creation works in transaction", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "newuser",
	"email" => "newuser@pleroma.social",
	"password" => "test"
	},
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	},
	%{
	"code" => 409,
	"data" => %{
	"email" => "newuser@pleroma.social",
	"nickname" => "newuser"
	},
	"error" => "",
	"type" => "error"
	}
	]

	assert User.get_by_nickname("newuser") === nil
	end
	end

	describe "/api/v1/pleroma/admin/users/:nickname" do
	test "Show", %{conn: conn} do
	user = insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}")

	assert user_response(user) == json_response_and_validate_schema(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	user = build(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}")

	assert %{"error" => "Not found"} == json_response_and_validate_schema(conn, 404)
	end
	end

	describe "/api/v1/pleroma/admin/users/follow" do
	test "allows to force-follow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/users/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
	end
	end

	describe "/api/v1/pleroma/admin/users/unfollow" do
	test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/admin/users/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
	end
	end

	describe "GET /api/v1/pleroma/admin/users" do
	test "renders users array for the first page", %{conn: conn, admin: admin} do
	user = insert(:user, local: false, tags: ["foo", "bar"])
	user2 = insert(:user, is_approved: false, registration_reason: "I'm a chill dude")

	conn = get(conn, "/api/v1/pleroma/admin/users?page=1")

	users = [
	user_response(
	user2,
	%{
	"local" => true,
	"is_approved" => false,
	"registration_reason" => "I'm a chill dude",
	"actor_type" => "Person"
	}
	),
	user_response(user, %{"local" => false, "tags" => ["foo", "bar"]}),
	user_response(
	admin,
	%{"roles" => %{"admin" => true, "moderator" => false}}
	)
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "pagination works correctly with service users", %{conn: conn} do
	service1 = User.get_or_create_service_actor_by_ap_id(Endpoint.url() <> "/meido", "meido")

	insert_list(25, :user)

	assert %{"count" => 26, "page_size" => 10, "users" => users1} =
	conn
	\|> get("/api/v1/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
	\|> json_response_and_validate_schema(200)

	assert Enum.count(users1) == 10
	assert service1 not in users1

	assert %{"count" => 26, "page_size" => 10, "users" => users2} =
	conn
	\|> get("/api/v1/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
	\|> json_response_and_validate_schema(200)

	assert Enum.count(users2) == 10
	assert service1 not in users2

	assert %{"count" => 26, "page_size" => 10, "users" => users3} =
	conn
	\|> get("/api/v1/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
	\|> json_response_and_validate_schema(200)

	assert Enum.count(users3) == 6
	assert service1 not in users3
	end

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?page=2")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	conn = get(conn, "/api/v1/pleroma/admin/users?query=bo")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user, %{"local" => true})]
	}
	end

	test "search by domain", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?query=domain.com")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?query=nickname@domain.com")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?name=display")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?email=email@example.com")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/v1/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response_and_validate_schema(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [user_response(user2)]
	}

	conn2 = get(conn, "/api/v1/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response_and_validate_schema(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [user_response(user)]
	}
	end

	test "only local users" do
	admin = insert(:user, is_admin: true, nickname: "john")
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/admin/users?query=bo&filters=local")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "only local users with no query", %{conn: conn, admin: old_admin} do
	admin = insert(:user, is_admin: true, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn = get(conn, "/api/v1/pleroma/admin/users?filters=local")

	users = [
	user_response(user),
	user_response(admin, %{
	"roles" => %{"admin" => true, "moderator" => false}
	}),
	user_response(old_admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	})
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "only unconfirmed users", %{conn: conn} do
	sad_user = insert(:user, nickname: "sadboy", is_confirmed: false)
	old_user = insert(:user, nickname: "oldboy", is_confirmed: false)

	insert(:user, nickname: "happyboy", is_approved: true)
	insert(:user, is_confirmed: true)

	result =
	conn
	\|> get("/api/v1/pleroma/admin/users?filters=unconfirmed")
	\|> json_response_and_validate_schema(200)

	users =
	Enum.map([old_user, sad_user], fn user ->
	user_response(user, %{
	"is_confirmed" => false,
	"is_approved" => true
	})
	end)

	assert result == %{"count" => 2, "page_size" => 50, "users" => users}
	end

	test "only unapproved users", %{conn: conn} do
	user =
	insert(:user,
	nickname: "sadboy",
	is_approved: false,
	registration_reason: "Plz let me in!"
	)

	insert(:user, nickname: "happyboy", is_approved: true)

	conn = get(conn, "/api/v1/pleroma/admin/users?filters=need_approval")

	users = [
	user_response(
	user,
	%{"is_approved" => false, "registration_reason" => "Plz let me in!"}
	)
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only admins", %{conn: conn, admin: admin} do
	second_admin = insert(:user, is_admin: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?filters=is_admin")

	users = [
	user_response(second_admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	}),
	user_response(admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	})
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only moderators", %{conn: conn} do
	moderator = insert(:user, is_moderator: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?filters=is_moderator")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	user_response(moderator, %{
	"is_active" => true,
	"roles" => %{"admin" => false, "moderator" => true}
	})
	]
	}
	end

	test "load users with actor_type is Person", %{admin: admin, conn: conn} do
	insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")

	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> get(user_path(conn, :index), %{actor_types: ["Person"]})
	\|> json_response_and_validate_schema(200)

	users = [
	user_response(user2),
	user_response(user1),
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]

	assert response == %{"count" => 3, "page_size" => 50, "users" => users}
	end

	test "load users with actor_type is Person and Service", %{admin: admin, conn: conn} do
	user_service = insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")

	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> get(user_path(conn, :index), %{actor_types: ["Person", "Service"]})
	\|> json_response_and_validate_schema(200)

	users = [
	user_response(user2),
	user_response(user1),
	user_response(user_service, %{"actor_type" => "Service"}),
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]

	assert response == %{"count" => 4, "page_size" => 50, "users" => users}
	end

	test "load users with actor_type is Service", %{conn: conn} do
	user_service = insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")
	insert(:user)
	insert(:user)

	response =
	conn
	\|> get(user_path(conn, :index), %{actor_types: ["Service"]})
	\|> json_response_and_validate_schema(200)

	users = [user_response(user_service, %{"actor_type" => "Service"})]

	assert response == %{"count" => 1, "page_size" => 50, "users" => users}
	end

	test "load users with tags list", %{conn: conn} do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/v1/pleroma/admin/users?tags[]=first&tags[]=second")

	users = [
	user_response(user2, %{"tags" => ["second"]}),
	user_response(user1, %{"tags" => ["first"]})
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "`active` filters out users pending approval", %{token: token} do
	insert(:user, is_approved: false)
	%{id: user_id} = insert(:user, is_approved: true)
	%{id: admin_id} = token.user

	conn =
	build_conn()
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/admin/users?filters=active")

	assert %{
	"count" => 2,
	"page_size" => 50,
	"users" => [
	%{"id" => ^user_id},
	%{"id" => ^admin_id}
	]
	} = json_response_and_validate_schema(conn, 200)
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob", local: false, is_active: false)

	insert(:user, nickname: "ken", local: true, is_active: false)
	insert(:user, nickname: "bobb", local: false, is_active: true)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/admin/users?filters=deactivated,external")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "it omits relay user", %{admin: admin, conn: conn} do
	assert %User{} = Relay.get_actor()

	conn = get(conn, "/api/v1/pleroma/admin/users")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]
	}
	end
	end

	test "PATCH /api/v1/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
	user_one = insert(:user, is_active: false)
	user_two = insert(:user, is_active: false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/v1/pleroma/admin/users/activate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response_and_validate_schema(conn, 200)
	assert Enum.map(response["users"], & &1["is_active"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/v1/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
	user_one = insert(:user, is_active: true)
	user_two = insert(:user, is_active: true)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/v1/pleroma/admin/users/deactivate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response_and_validate_schema(conn, 200)
	assert Enum.map(response["users"], & &1["is_active"]) == [false, false]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/v1/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
	user_one = insert(:user, is_approved: false)
	user_two = insert(:user, is_approved: false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/v1/pleroma/admin/users/approve",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response_and_validate_schema(conn, 200)
	assert Enum.map(response["users"], & &1["is_approved"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} approved users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/v1/pleroma/admin/users/suggest", %{admin: admin, conn: conn} do
	user1 = insert(:user, is_suggested: false)
	user2 = insert(:user, is_suggested: false)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/v1/pleroma/admin/users/suggest",
	%{nicknames: [user1.nickname, user2.nickname]}
	)
	\|> json_response_and_validate_schema(200)

	assert Enum.map(response["users"], & &1["is_suggested"]) == [true, true]
	[user1, user2] = Repo.reload!([user1, user2])

	assert user1.is_suggested
	assert user2.is_suggested

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} added suggested users: @#{user1.nickname}, @#{user2.nickname}"
	end

	test "PATCH /api/v1/pleroma/admin/users/unsuggest", %{admin: admin, conn: conn} do
	user1 = insert(:user, is_suggested: true)
	user2 = insert(:user, is_suggested: true)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/v1/pleroma/admin/users/unsuggest",
	%{nicknames: [user1.nickname, user2.nickname]}
	)
	\|> json_response_and_validate_schema(200)

	assert Enum.map(response["users"], & &1["is_suggested"]) == [false, false]
	[user1, user2] = Repo.reload!([user1, user2])

	refute user1.is_suggested
	refute user2.is_suggested

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} removed suggested users: @#{user1.nickname}, @#{user2.nickname}"
	end

	test "PATCH /api/v1/pleroma/admin/users/:nickname/toggle_activation", %{
	admin: admin,
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/v1/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response_and_validate_schema(conn, 200) ==
	user_response(
	user,
	%{"is_active" => !user.is_active}
	)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user.nickname}"
	end

	defp user_response(user, attrs \\ %{}) do
	%{
	"is_active" => user.is_active,
	"id" => user.id,
	"email" => user.email,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"is_confirmed" => true,
	"is_approved" => true,
	"is_suggested" => false,
	"url" => user.ap_id,
	"registration_reason" => nil,
	"actor_type" => "Person",
	"created_at" => CommonAPI.Utils.to_masto_date(user.inserted_at)
	}
	\|> Map.merge(attrs)
	end
	end
	diff --git a/test/pleroma/web/common_api_test.exs b/test/pleroma/web/common_api_test.exs
	index 6a95d8023..f2675ad01 100644
	--- a/test/pleroma/web/common_api_test.exs
	+++ b/test/pleroma/web/common_api_test.exs
	@@ -1,1457 +1,1458 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.PollWorker

	import Pleroma.Factory
	import Mock
	import Ecto.Query, only: [from: 2]

	require Pleroma.Constants

	setup_all do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([Pleroma.Uploaders.Local, :uploads], "uploads")
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	describe "posting polls" do
	test "it posts a poll" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "who is the best",
	poll: %{expires_in: 600, options: ["reimu", "marisa"]}
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["type"] == "Question"
	assert object.data["oneOf"] \|> length() == 2

	{:ok, time, _} = DateTime.from_iso8601(object.data["closed"])

	assert_enqueued(
	worker: PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: time
	)
	end
	end

	describe "blocking" do
	setup do
	blocker = insert(:user)
	blocked = insert(:user, local: false)
	CommonAPI.follow(blocker, blocked)
	CommonAPI.follow(blocked, blocker)
	CommonAPI.accept_follow_request(blocker, blocked)
	CommonAPI.accept_follow_request(blocked, blocked)
	%{blocker: blocker, blocked: blocked}
	end

	test "it blocks and federates", %{blocker: blocker, blocked: blocked} do
	clear_config([:instance, :federating], true)
	clear_config([:activitypub, :outgoing_blocks], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert User.get_follow_state(blocker, blocked) == :follow_accept
	refute is_nil(Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked))

	assert {:ok, block} = CommonAPI.block(blocker, blocked)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute User.get_follow_state(blocker, blocked)

	assert %{data: %{"state" => "reject"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked)

	assert called(Pleroma.Web.Federator.publish(block))
	end
	end

	test "it blocks and does not federate if outgoing blocks are disabled", %{
	blocker: blocker,
	blocked: blocked
	} do
	clear_config([:instance, :federating], true)
	clear_config([:activitypub, :outgoing_blocks], false)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, block} = CommonAPI.block(blocker, blocked)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute called(Pleroma.Web.Federator.publish(block))
	end
	end
	end

	describe "unblocking" do
	test "it works even without an existing block activity" do
	blocked = insert(:user)
	blocker = insert(:user)
	User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	assert {:ok, :no_activity} == CommonAPI.unblock(blocker, blocked)
	refute User.blocks?(blocker, blocked)
	end
	end

	describe "deletion" do
	test "it works with pruned objects" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	Object.normalize(post, fetch: false)
	\|> Object.prune()

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows users to delete their posts" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it does not allow a user to delete their posts" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
	assert Activity.get_by_id(post.id)
	end

	test "it allows moderators to delete other user's posts" do
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "it allows admins to delete other user's posts" do
	user = insert(:user)
	moderator = insert(:user, is_admin: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "superusers deleting non-local posts won't federate the delete" do
	# This is the user of the ingested activity
	_user =
	insert(:user,
	local: false,
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: NaiveDateTime.utc_now()
	)

	moderator = insert(:user, is_admin: true)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	{:ok, post} = Transmogrifier.handle_incoming(data)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local
	refute called(Pleroma.Web.Federator.publish(:_))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows privileged users to delete banned user's posts" do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
	User.set_activation(user, false)

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end
	end

	test "favoriting race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.favorite(user, activity.id)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.favorite(user, activity.id)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 20
	end

	test "repeating race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.repeat(activity.id, user)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.repeat(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 20
	end

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})

	assert Visibility.is_direct?(convo_reply)

	assert activity.data["context"] == convo_reply.data["context"]
	end

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey",
	visibility: "direct"
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "I don't really like @#{tridi.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

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

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	visibility: "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})

	object = Object.normalize(activity, fetch: false)

	assert Object.tags(object) == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})

	assert Object.normalize(activity, fetch: false).data["emoji"]["firefox"]
	end

	describe "posting" do
	test "it adds an emoji on an external site" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey :external_emoji:"})

	assert %{"external_emoji" => url} = Object.normalize(activity).data["emoji"]
	assert url == "https://example.com/emoji.png"

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

	assert %{"blank" => url} = Object.normalize(activity).data["emoji"]
	assert url == "#{Pleroma.Web.Endpoint.url()}/emoji/blank.png"
	end

	test "it copies emoji from the subject of the parent post" do
	%Object{} =
	object =
	Object.normalize("https://patch.cx/objects/a399c28e-c821-4820-bc3e-4afeb044c16f",
	fetch: true
	)

	activity = Activity.get_create_by_object_ap_id(object.data["id"])
	user = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(user, %{
	in_reply_to_id: activity.id,
	status: ":joker_disapprove:",
	spoiler_text: ":joker_smile:"
	})

	assert Object.normalize(reply_activity).data["emoji"]["joker_smile"]
	refute Object.normalize(reply_activity).data["emoji"]["joker_disapprove"]
	end

	test "deactivated users can't post" do
	user = insert(:user, is_active: false)
	assert {:error, _} = CommonAPI.post(user, %{status: "ye"})
	end

	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	to: [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/html"
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"

	assert object.data["source"] == %{
	"mediaType" => "text/html",
	"content" => post
	}
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/markdown"
	})

	object = Object.normalize(activity, fetch: false)

	assert object.data["content"] == "<p><b>2hu</b></p>"

	assert object.data["source"] == %{
	"mediaType" => "text/markdown",
	"content" => post
	}
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: visibility,
	in_reply_to_status_id: activity.id
	})
	end)
	end

	test "replying with a direct message will NOT auto-add the author of the reply to the recipient list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "I'm stupid"})

	{:ok, open_answer} =
	CommonAPI.post(other_user, %{status: "No ur smart", in_reply_to_status_id: post.id})

	# The OP is implicitly added
	assert user.ap_id in open_answer.recipients

	{:ok, secret_answer} =
	CommonAPI.post(other_user, %{
	status: "lol, that guy really is stupid, right, @#{third_user.nickname}?",
	in_reply_to_status_id: post.id,
	visibility: "direct"
	})

	assert third_user.ap_id in secret_answer.recipients

	# The OP is not added
	refute user.ap_id in secret_answer.recipients
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	assert activity.data["bcc"] == [list.ap_id]
	assert activity.recipients == [list.ap_id, user.ap_id]
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{status: ""})
	end

	test "it validates character limits are correctly enforced" do
	clear_config([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{status: "foobar"})

	assert {:ok, _activity} = CommonAPI.post(user, %{status: "12345"})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)

	assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at: expires_at
	)
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

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

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	assert unreaction.local

	# On federation, it contains the undone (and deleted) object
	unreaction_with_object = %{
	unreaction
	\| data: Map.put(unreaction.data, "object", reaction.data)
	}

	assert called(Pleroma.Web.Federator.publish(unreaction_with_object))
	end
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, user)
	assert Visibility.is_public?(announce_activity)
	end

	test "can't repeat a repeat" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, other_user)

	refute match?({:ok, %Activity{}}, CommonAPI.repeat(announce.id, user))
	end

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} =
	CommonAPI.repeat(activity.id, user, %{visibility: "private"})

	assert Visibility.is_private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)
	end

	test "author can repeat own private statuses" do
	author = insert(:user)
	follower = insert(:user)
	CommonAPI.follow(follower, author)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, author)

	assert Visibility.is_private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)

	assert Visibility.visible_for_user?(activity, follower)
	assert {:error, :not_found} = CommonAPI.repeat(activity.id, follower)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post_activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
	assert data["type"] == "Like"
	assert data["actor"] == user.ap_id
	assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, user)
	{:ok, ^announce} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
	assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
	end
	end

	describe "pinned statuses" do
	setup do
	clear_config([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "activity not found error", %{user: user} do
	assert {:error, :not_found} = CommonAPI.pin("id", user)
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)
	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How is fediverse today?",
	poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)

	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, :ownership_error} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity_two.id, user)
	end

	test "only public can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "private status", visibility: "private"})
	{:error, :visibility_error} = CommonAPI.pin(activity.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	id = activity.id

	assert match?({:ok, %{id: ^id}}, CommonAPI.unpin(activity.id, user))

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, _} = CommonAPI.delete(activity.id, user)

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "ephemeral activity won't be deleted if was pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "Hello!", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)
	refute Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	user = refresh_record(user)
	{:ok, _} = CommonAPI.unpin(activity.id, user)

	# recreates expiration job on unpin
	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)
	end

	test "ephemeral activity deletion job won't be deleted on pinning error", %{
	user: user,
	activity: activity
	} do
	clear_config([:instance, :max_pinned_statuses], 1)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)

	{:ok, activity2} = CommonAPI.post(user, %{status: "another status", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)

	user = refresh_record(user)
	{:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity2.id, user)

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "marks notifications as read after mute" do
	author = insert(:user)
	activity = insert(:note_activity, user: author)

	friend1 = insert(:user)
	friend2 = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(
	friend2,
	%{
	status: "@#{author.nickname} @#{friend1.nickname} test reply",
	in_reply_to_status_id: activity.id
	}
	)

	{:ok, favorite_activity} = CommonAPI.favorite(friend2, activity.id)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, friend1)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	unread_notifications =
	Repo.all(from(n in Notification, where: n.seen == false, where: n.user_id == ^author.id))

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)

	{:ok, _} = CommonAPI.add_mute(author, activity)
	assert CommonAPI.thread_muted?(author, activity)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	read_notifications =
	Repo.all(from(n in Notification, where: n.seen == true, where: n.user_id == ^author.id))

	assert Enum.any?(read_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "add expiring mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity, %{expires_in: 60})
	assert CommonAPI.thread_muted?(user, activity)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_conversation", "user_id" => user.id, "activity_id" => activity.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute by ids", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user.id, activity.id)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	account_id: target_user.id,
	comment: comment,
	status_ids: [activity.id]
	}

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => "foobar",
	"published" => activity.object.data["published"],
	"actor" => AccountView.render("show.json", %{user: target_user})
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, activity_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert activity_id == activity.data["id"]
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel very offended!",
	status_ids: [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "follow/2" do
	test "directly follows a non-locked local user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)

	assert User.following?(follower, followed)
	end
	end

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(follower, followed)

	refute User.subscribed_to?(follower, followed)
	end

	test "removes a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	assert {:ok, follower, followed, %{id: _activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert is_nil(Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed))

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true, local: false, ap_enabled: true)

	assert {:ok, follower, followed, %{id: _activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert is_nil(Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed))

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_three} = CommonAPI.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_three} = CommonAPI.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "doesn't create a following relationship if the corresponding follow request doesn't exist" do
	user = insert(:user, is_locked: true)
	not_follower = insert(:user)
	CommonAPI.accept_follow_request(not_follower, user)

	assert Pleroma.FollowingRelationship.following?(not_follower, user) == false
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

	object = Object.normalize(activity, fetch: false)

	{:ok, _, object} = CommonAPI.vote(other_user, object, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(other_user, object, [1])
	end
	end

	describe "get_user/1" do
	test "gets user by ap_id" do
	user = insert(:user)
	assert CommonAPI.get_user(user.ap_id) == user
	end

	test "gets user by guessed nickname" do
	user = insert(:user, ap_id: "", nickname: "mario@mushroom.kingdom")
	assert CommonAPI.get_user("https://mushroom.kingdom/users/mario") == user
	end

	test "fallback" do
	assert %User{
	name: "",
	ap_id: "",
	nickname: "erroruser@example.com"
	} = CommonAPI.get_user("")
	end
	end

	describe "with `local` visibility" do
	setup do: clear_config([:instance, :federating], true)

	test "post" do
	user = insert(:user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	assert Visibility.is_local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "delete" do
	user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"deleted_activity_id" => ^activity_id}} = activity} =
	CommonAPI.delete(activity_id, user)

	assert Visibility.is_local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "repeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Announce"}} = activity} =
	CommonAPI.repeat(activity_id, user)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unrepeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	assert {:ok, _} = CommonAPI.repeat(activity_id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unrepeat(activity_id, user)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "favorite" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Like"}} = activity} =
	CommonAPI.favorite(user, activity.id)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unfavorite" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, activity} = CommonAPI.unfavorite(activity.id, user)
	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "react_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "EmojiReact"}} = activity} =
	CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unreact_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, _reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end

	describe "update/3" do
	test "updates a post" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1"})

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end

	test "does not change visibility" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1", visibility: "private"})

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Visibility.get_visibility(updated_object) == "private"
	assert Visibility.get_visibility(updated) == "private"
	end

	test "updates a post with emoji" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2 :#{emoji2}:"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated_object.data["emoji"]
	end

	test "updates a post with emoji and federate properly" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _p -> nil end do
	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2 :#{emoji2}:"})

	assert updated.data["object"]["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated.data["object"]["emoji"]

	assert called(Pleroma.Web.Federator.publish(updated))
	end
	end

	test "editing a post that copied a remote title with remote emoji should keep that emoji" do
	remote_emoji_uri = "https://remote.org/emoji.png"

	note =
	insert(
	:note,
	data: %{
	"summary" => ":remoteemoji:",
	"emoji" => %{
	"remoteemoji" => remote_emoji_uri
	},
	"tag" => [
	%{
	"type" => "Emoji",
	"name" => "remoteemoji",
	"icon" => %{"url" => remote_emoji_uri}
	}
	]
	}
	)

	note_activity = insert(:note_activity, note: note)

	user = insert(:user)

	{:ok, reply} =
	CommonAPI.post(user, %{
	status: "reply",
	spoiler_text: ":remoteemoji:",
	in_reply_to_id: note_activity.id
	})

	assert reply.object.data["emoji"]["remoteemoji"] == remote_emoji_uri

	{:ok, edit} =
	CommonAPI.update(user, reply, %{status: "reply mew mew", spoiler_text: ":remoteemoji:"})

	edited_note = Pleroma.Object.normalize(edit)

	assert edited_note.data["emoji"]["remoteemoji"] == remote_emoji_uri
	end

	test "respects MRF" do
	user = insert(:user)

	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
	clear_config([:mrf_keyword, :replace], [{"updated", "mewmew"}])

	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "updated 1"})
	assert Object.normalize(activity).data["summary"] == "mewmew 1"

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "mewmew 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end
	end
	end
	diff --git a/test/pleroma/web/federator_test.exs b/test/pleroma/web/federator_test.exs
	index 394ab329e..76a7a6d37 100644
	--- a/test/pleroma/web/federator_test.exs
	+++ b/test/pleroma/web/federator_test.exs
	@@ -1,175 +1,176 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.FederatorTest do
	alias Pleroma.Instances
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.PublisherWorker

	use Pleroma.DataCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import Mock

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

	:ok
	end

	setup_all do: clear_config([:instance, :federating], true)
	setup do: clear_config([:instance, :allow_relay], true)
	setup do: clear_config([:mrf, :policies])
	setup do: clear_config([:mrf_keyword])

	describe "Publish an activity" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI"})

	relay_mock = {
	Pleroma.Web.ActivityPub.Relay,
	[],
	[publish: fn _activity -> send(self(), :relay_publish) end]
	}

	%{activity: activity, relay_mock: relay_mock}
	end

	test "with relays active, it publishes to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	with_mocks([relay_mock]) do
	Federator.publish(activity)
	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))
	end

	assert_receive :relay_publish
	end

	test "with relays deactivated, it does not publish to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	clear_config([:instance, :allow_relay], false)

	with_mocks([relay_mock]) do
	Federator.publish(activity)
	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))
	end

	refute_received :relay_publish
	end
	end

	describe "Targets reachability filtering in `publish`" do
	test "it federates only to reachable instances via AP" do
	user = insert(:user)

	{inbox1, inbox2} =
	{"https://domain.com/users/nick1/inbox", "https://domain2.com/users/nick2/inbox"}

	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	inbox: inbox1,
	ap_enabled: true
	})

	insert(:user, %{
	local: false,
	nickname: "nick2@domain2.com",
	ap_id: "https://domain2.com/users/nick2",
	inbox: inbox2,
	ap_enabled: true
	})

	dt = NaiveDateTime.utc_now()
	Instances.set_unreachable(inbox1, dt)

	Instances.set_consistently_unreachable(URI.parse(inbox2).host)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "HI @nick1@domain.com, @nick2@domain2.com!"})

	expected_dt = NaiveDateTime.to_iso8601(dt)

	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))

	assert ObanHelpers.member?(
	%{
	"op" => "publish_one",
	"params" => %{"inbox" => inbox1, "unreachable_since" => expected_dt}
	},
	all_enqueued(worker: PublisherWorker)
	)
	end
	end

	describe "Receive an activity" do
	test "successfully processes incoming AP docs with correct origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:ok, _activity} = ObanHelpers.perform(job)

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:error, :already_present} = ObanHelpers.perform(job)
	end

	test "rejects incoming AP docs with incorrect origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://niu.moe/users/rye",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:discard, :origin_containment_failed} = ObanHelpers.perform(job)
	end

	test "it does not crash if MRF rejects the post" do
	clear_config([:mrf_keyword, :reject], ["lain"])

	clear_config(
	[:mrf, :policies],
	Pleroma.Web.ActivityPub.MRF.KeywordPolicy
	)

	params =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:discard, _} = ObanHelpers.perform(job)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	index 1d8a67e6b..916b02d0c 100644
	--- a/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	@@ -1,446 +1,447 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.Filter
	alias Pleroma.Repo
	alias Pleroma.Workers.PurgeExpiredFilter

	test "non authenticated creation request", %{conn: conn} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{"phrase" => "knights", context: ["home"]})
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end

	describe "creating" do
	setup do: oauth_access(["write:filters"])

	test "a common filter", %{conn: conn, user: user} do
	params = %{
	phrase: "knights",
	context: ["home"],
	irreversible: true
	}

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", params)
	\|> json_response_and_validate_schema(200)

	assert response["phrase"] == params.phrase
	assert response["context"] == params.context
	assert response["irreversible"] == true
	assert response["id"] != nil
	assert response["id"] != ""
	assert response["expires_at"] == nil

	filter = Filter.get(response["id"], user)
	assert filter.hide == true
	end

	test "a filter with expires_in", %{conn: conn, user: user} do
	in_seconds = 600

	response =
	with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	"phrase" => "knights",
	context: ["home"],
	expires_in: in_seconds
	})
	\|> json_response_and_validate_schema(200)
	end

	assert response["irreversible"] == false

	assert response["expires_at"] == "2017-03-17T17:19:58.000Z"

	filter = Filter.get(response["id"], user)

	id = filter.id

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert {:ok, %{id: ^id}} =
	perform_job(PurgeExpiredFilter, %{
	filter_id: filter.id
	})

	assert Repo.aggregate(Filter, :count, :id) == 0
	end

	test "a filter with expires_at", %{conn: conn, user: user} do
	response =
	with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	"phrase" => "bad memes",
	context: ["home"],
	expires_at: "2017-03-17T17:19:58.000Z"
	})
	\|> json_response_and_validate_schema(200)
	end

	assert response["irreversible"] == false

	assert response["expires_at"] == "2017-03-17T17:19:58.000Z"

	filter = Filter.get(response["id"], user)

	id = filter.id

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert {:ok, %{id: ^id}} =
	perform_job(PurgeExpiredFilter, %{
	filter_id: filter.id
	})

	assert Repo.aggregate(Filter, :count, :id) == 0
	end
	end

	test "fetching a list of filters" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

	%{filter_id: id1} = insert(:filter, user: user)
	%{filter_id: id2} = insert(:filter, user: user)

	id1 = to_string(id1)
	id2 = to_string(id2)

	assert [%{"id" => ^id2}, %{"id" => ^id1}] =
	conn
	\|> get("/api/v1/filters")
	\|> json_response_and_validate_schema(200)
	end

	test "fetching a list of filters without token", %{conn: conn} do
	insert(:filter)

	response =
	conn
	\|> get("/api/v1/filters")
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end

	test "get a filter" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

	# check whole_word false
	filter = insert(:filter, user: user, whole_word: false)

	resp1 =
	conn \|> get("/api/v1/filters/#{filter.filter_id}") \|> json_response_and_validate_schema(200)

	assert resp1["whole_word"] == false

	# check whole_word true
	filter = insert(:filter, user: user, whole_word: true)

	resp2 =
	conn \|> get("/api/v1/filters/#{filter.filter_id}") \|> json_response_and_validate_schema(200)

	assert resp2["whole_word"] == true
	end

	test "get a filter not_found error" do
	filter = insert(:filter)
	%{conn: conn} = oauth_access(["read:filters"])

	response =
	conn \|> get("/api/v1/filters/#{filter.filter_id}") \|> json_response_and_validate_schema(404)

	assert response["error"] == "Record not found"
	end

	describe "updating a filter" do
	setup do: oauth_access(["write:filters"])

	test "common" do
	%{conn: conn, user: user} = oauth_access(["write:filters"])

	filter =
	insert(:filter,
	user: user,
	hide: true,
	whole_word: true
	)

	params = %{
	phrase: "nii",
	context: ["public"],
	irreversible: false
	}

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", params)
	\|> json_response_and_validate_schema(200)

	assert response["phrase"] == params.phrase
	assert response["context"] == params.context
	assert response["irreversible"] == false
	assert response["whole_word"] == true
	end

	test "with adding expires_at", %{conn: conn, user: user} do
	filter = insert(:filter, user: user)
	in_seconds = 600

	response =
	with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"],
	expires_in: in_seconds,
	irreversible: true
	})
	\|> json_response_and_validate_schema(200)
	end

	assert response["irreversible"] == true

	assert response["expires_at"] == "2017-03-17T17:19:58.000Z"

	filter = Filter.get(response["id"], user)

	id = filter.id

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: id}
	)

	assert {:ok, %{id: ^id}} =
	perform_job(PurgeExpiredFilter, %{
	filter_id: id
	})

	assert Repo.aggregate(Filter, :count, :id) == 0
	end

	test "with removing expires_at", %{conn: conn, user: user} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(response["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"],
	expires_in: nil,
	whole_word: true
	})
	\|> json_response_and_validate_schema(200)

	refute_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert response["irreversible"] == false
	assert response["whole_word"] == true
	assert response["expires_at"] == nil
	end

	test "expires_at is the same in create and update so job is in db", %{conn: conn, user: user} do
	resp1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(resp1["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	job = PurgeExpiredFilter.get_expiration(filter.id)

	resp2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"]
	})
	\|> json_response_and_validate_schema(200)

	updated_filter = Filter.get(resp2["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: updated_filter.id}
	)

	after_update = PurgeExpiredFilter.get_expiration(updated_filter.id)

	assert resp1["expires_at"] == resp2["expires_at"]

	assert job.scheduled_at == after_update.scheduled_at
	end

	test "updating expires_at updates oban job too", %{conn: conn, user: user} do
	resp1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(resp1["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	job = PurgeExpiredFilter.get_expiration(filter.id)

	resp2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"],
	expires_in: 300
	})
	\|> json_response_and_validate_schema(200)

	updated_filter = Filter.get(resp2["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: updated_filter.id}
	)

	after_update = PurgeExpiredFilter.get_expiration(updated_filter.id)

	refute resp1["expires_at"] == resp2["expires_at"]

	refute job.scheduled_at == after_update.scheduled_at
	end
	end

	test "update filter without token", %{conn: conn} do
	filter = insert(:filter)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"]
	})
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end

	describe "delete a filter" do
	setup do: oauth_access(["write:filters"])

	test "common", %{conn: conn, user: user} do
	filter = insert(:filter, user: user)

	assert conn
	\|> delete("/api/v1/filters/#{filter.filter_id}")
	\|> json_response_and_validate_schema(200) == %{}

	assert Repo.all(Filter) == []
	end

	test "with expires_at", %{conn: conn, user: user} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(response["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert conn
	\|> delete("/api/v1/filters/#{filter.filter_id}")
	\|> json_response_and_validate_schema(200) == %{}

	refute_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert Repo.all(Filter) == []
	assert Repo.all(Oban.Job) == []
	end
	end

	test "delete a filter without token", %{conn: conn} do
	filter = insert(:filter)

	response =
	conn
	\|> delete("/api/v1/filters/#{filter.filter_id}")
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	index 3dc56c3bf..6a0d25058 100644
	--- a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	@@ -1,223 +1,224 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Mock

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

	describe ".search2" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v2/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu #private"})}")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == [
	%{"name" => "private", "url" => "#{Endpoint.url()}/tag/private"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)

	results =
	get(conn, "/api/v2/search?q=天子")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "天子", "url" => "#{Endpoint.url()}/tag/天子"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	@tag capture_log: true
	test "constructs hashtags from search query", %{conn: conn} do
	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "explicit", "url" => "#{Endpoint.url()}/tag/explicit"},
	%{"name" => "hashtags", "url" => "#{Endpoint.url()}/tag/hashtags"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "john", "url" => "#{Endpoint.url()}/tag/john"},
	%{"name" => "doe", "url" => "#{Endpoint.url()}/tag/doe"},
	%{"name" => "JohnDoe", "url" => "#{Endpoint.url()}/tag/JohnDoe"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "accident", "url" => "#{Endpoint.url()}/tag/accident"},
	%{"name" => "prone", "url" => "#{Endpoint.url()}/tag/prone"},
	%{"name" => "AccidentProne", "url" => "#{Endpoint.url()}/tag/AccidentProne"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "https://shpposter.club/users/shpuld"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "shpuld", "url" => "#{Endpoint.url()}/tag/shpuld"}
	]

	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "https://www.washingtonpost.com/sports/2020/06/10/" <> "nascar-ban-display-confederate-flag-all-events-properties/"})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "nascar", "url" => "#{Endpoint.url()}/tag/nascar"},
	%{"name" => "ban", "url" => "#{Endpoint.url()}/tag/ban"},
	%{"name" => "display", "url" => "#{Endpoint.url()}/tag/display"},
	%{"name" => "confederate", "url" => "#{Endpoint.url()}/tag/confederate"},
	%{"name" => "flag", "url" => "#{Endpoint.url()}/tag/flag"},
	%{"name" => "all", "url" => "#{Endpoint.url()}/tag/all"},
	%{"name" => "events", "url" => "#{Endpoint.url()}/tag/events"},
	%{"name" => "properties", "url" => "#{Endpoint.url()}/tag/properties"},
	%{
	"name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
	"url" =>
	"#{Endpoint.url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
	}
	]
	end

	test "supports pagination of hashtags search results", %{conn: conn} do
	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "#some #text #with #hashtags", limit: 2, offset: 1})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "text", "url" => "#{Endpoint.url()}/tag/text"},
	%{"name" => "with", "url" => "#{Endpoint.url()}/tag/with"}
	]
	end

	test "excludes a blocked users from search results", %{conn: conn} do
	user = insert(:user)
	user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
	user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})

	{:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
	{:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
	{:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
	Pleroma.User.block(user, user_smith)

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v2/search?q=Agent")
	\|> json_response_and_validate_schema(200)

	status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)

	assert act3.id in status_ids
	refute act2.id in status_ids
	refute act1.id in status_ids
	end
	end

	describe ".account_search" do
	test "account search", %{conn: conn} do
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> get("/api/v1/accounts/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "returns account if query contains a space", %{conn: conn} do
	insert(:user, %{nickname: "shp@shitposter.club"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
	\|> json_response_and_validate_schema(200)

	assert length(results) == 1
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/update_credentials_test.exs b/test/pleroma/web/mastodon_api/update_credentials_test.exs
	index 2e80b6f6b..a347c7987 100644
	--- a/test/pleroma/web/mastodon_api/update_credentials_test.exs
	+++ b/test/pleroma/web/mastodon_api/update_credentials_test.exs
	@@ -1,784 +1,785 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.UpdateCredentialsTest do
	alias Pleroma.Repo
	alias Pleroma.User

	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import Mock
	import Pleroma.Factory

	setup do: clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	describe "updating credentials" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "sets user settings in a generic way", %{conn: conn} do
	res_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	pleroma_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)
	assert user_data["pleroma"]["settings_store"] == %{"pleroma_fe" => %{"theme" => "bla"}}

	user = Repo.get(User, user_data["id"])

	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "bla"}
	}

	user = Repo.get(User, user_data["id"])

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

	with_mock Pleroma.Web.Federator,
	publish: fn _activity -> :ok end do
	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "blub"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "blub"}
	}

	assert_called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "updates the user's bio", %{conn: conn} do
	user2 = insert(:user)

	raw_bio = "I drink #cofe with @#{user2.nickname}\n\nsuya.."

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"note" => raw_bio})

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] ==
	~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe">#cofe</a> with <span class="h-card"><a class="u-url mention" data-user="#{user2.id}" href="#{user2.ap_id}" rel="ugc">@<span>#{user2.nickname}</span></a></span><br/><br/>suya..)

	assert user_data["source"]["note"] == raw_bio

	user = Repo.get(User, user_data["id"])

	assert user.raw_bio == raw_bio
	end

	test "updates the user's locking status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["locked"] == true
	end

	test "updates the user's allow_following_move", %{user: user, conn: conn} do
	assert user.allow_following_move == true

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{allow_following_move: "false"})

	assert refresh_record(user).allow_following_move == false
	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["allow_following_move"] == false
	end

	test "updates the user's default scope", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{default_scope: "unlisted"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's privacy", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{source: %{privacy: "unlisted"}})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's hide_followers status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_followers: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers"] == true
	end

	test "updates the user's discoverable status", %{conn: conn} do
	assert %{"source" => %{"pleroma" => %{"discoverable" => true}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "true"})
	\|> json_response_and_validate_schema(:ok)

	assert %{"source" => %{"pleroma" => %{"discoverable" => false}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "false"})
	\|> json_response_and_validate_schema(:ok)
	end

	test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	hide_followers_count: "true",
	hide_follows_count: "true"
	})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers_count"] == true
	assert user_data["pleroma"]["hide_follows_count"] == true
	end

	test "updates the user's skip_thread_containment option", %{user: user, conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
	\|> json_response_and_validate_schema(200)

	assert response["pleroma"]["skip_thread_containment"] == true
	assert refresh_record(user).skip_thread_containment
	end

	test "updates the user's hide_follows status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_follows: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_follows"] == true
	end

	test "updates the user's hide_favorites status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_favorites: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_favorites"] == true
	end

	test "updates the user's show_role status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{show_role: "false"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["show_role"] == false
	end

	test "updates the user's no_rich_text status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{no_rich_text: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["no_rich_text"] == true
	end

	test "updates the user's name", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["display_name"] == "markorepairs"

	update_activity = Repo.one(Pleroma.Activity)
	assert update_activity.data["type"] == "Update"
	assert update_activity.data["object"]["name"] == "markorepairs"
	end

	test "updates the user's default post expiry", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"status_ttl_days" => "1"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["akkoma"]["status_ttl_days"] == 1
	end

	test "resets the user's default post expiry", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"status_ttl_days" => "-1"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert is_nil(user_data["akkoma"]["status_ttl_days"])
	end

	test "does not allow negative integers other than -1 for TTL", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"status_ttl_days" => "-2"})

	assert json_response_and_validate_schema(conn, 403)
	end

	test "updates the user's AKAs", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"also_known_as" => ["https://mushroom.kingdom/users/mario"]
	})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["also_known_as"] == ["https://mushroom.kingdom/users/mario"]
	end

	test "doesn't update non-url akas", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"also_known_as" => ["aReallyCoolGuy"]
	})

	assert json_response_and_validate_schema(conn, 403)
	end

	test "updates the user's avatar", %{user: user, conn: conn} do
	new_avatar = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	assert user.avatar == %{}

	res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["avatar"] != User.avatar_url(user)

	user = User.get_by_id(user.id)
	refute user.avatar == %{}

	# Also resets it
	_res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => ""})

	user = User.get_by_id(user.id)
	assert user.avatar == nil
	end

	test "updates the user's avatar, upload_limit, returns a HTTP 413", %{conn: conn, user: user} do
	upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8

	assert :ok ==
	File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)

	new_avatar_oversized = %Plug.Upload{
	content_type: nil,
	path: Path.absname("test/tmp/large_binary.data"),
	filename: "large_binary.data"
	}

	assert user.avatar == %{}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar_oversized})

	assert user_response = json_response_and_validate_schema(res, 413)
	assert user_response["avatar"] != User.avatar_url(user)

	user = User.get_by_id(user.id)
	assert user.avatar == %{}

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

	assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
	end

	test "updates the user's banner", %{user: user, conn: conn} do
	new_header = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["header"] != User.banner_url(user)

	# Also resets it
	_res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => ""})

	user = User.get_by_id(user.id)
	assert user.banner == nil
	end

	test "updates the user's banner, upload_limit, returns a HTTP 413", %{conn: conn, user: user} do
	upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8

	assert :ok ==
	File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)

	new_header_oversized = %Plug.Upload{
	content_type: nil,
	path: Path.absname("test/tmp/large_binary.data"),
	filename: "large_binary.data"
	}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header_oversized})

	assert user_response = json_response_and_validate_schema(res, 413)
	assert user_response["header"] != User.banner_url(user)

	user = User.get_by_id(user.id)
	assert user.banner == %{}

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

	assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
	end

	test "updates the user's background", %{conn: conn, user: user} do
	new_header = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_background_image" => new_header
	})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["pleroma"]["background_image"]
	#
	# Also resets it
	_res =
	patch(conn, "/api/v1/accounts/update_credentials", %{"pleroma_background_image" => ""})

	user = User.get_by_id(user.id)
	assert user.background == nil
	end

	test "updates the user's background, upload_limit, returns a HTTP 413", %{
	conn: conn,
	user: user
	} do
	upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8

	assert :ok ==
	File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)

	new_background_oversized = %Plug.Upload{
	content_type: nil,
	path: Path.absname("test/tmp/large_binary.data"),
	filename: "large_binary.data"
	}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_background_image" => new_background_oversized
	})

	assert json_response_and_validate_schema(res, 413)
	assert user.background == %{}

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

	assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
	end

	test "Strip / from upload files", %{user: user, conn: conn} do
	new_image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "../../../../nested/an_image.jpg"
	}

	assert user.avatar == %{}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"avatar" => new_image,
	"header" => new_image,
	"pleroma_background_image" => new_image
	})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["avatar"]
	assert user_response["header"]
	assert user_response["pleroma"]["background_image"]
	refute Regex.match?(~r"/nested/", user_response["avatar"])
	refute Regex.match?(~r"/nested/", user_response["header"])
	refute Regex.match?(~r"/nested/", user_response["pleroma"]["background_image"])

	user = User.get_by_id(user.id)
	refute user.avatar == %{}
	end

	test "requires 'write:accounts' permission" do
	token1 = insert(:oauth_token, scopes: ["read"])
	token2 = insert(:oauth_token, scopes: ["write", "follow"])

	for token <- [token1, token2] do
	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> patch("/api/v1/accounts/update_credentials", %{})

	if token == token1 do
	assert %{"error" => "Insufficient permissions: write:accounts."} ==
	json_response_and_validate_schema(conn, 403)
	else
	assert json_response_and_validate_schema(conn, 200)
	end
	end
	end

	test "updates profile emojos", %{user: user, conn: conn} do
	note = "sips :blank:"
	name = "I am :firefox:"

	ret_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"note" => note,
	"display_name" => name
	})

	assert json_response_and_validate_schema(ret_conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}")

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] == note
	assert user_data["display_name"] == name
	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user_data["emojis"]
	end

	test "update fields", %{conn: conn} do
	fields = [
	%{name: "<a href=\"http://google.com\">foo</a>", value: "<script>bar</script>"},
	%{name: "link.io", value: "cofe.io"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "bar"},
	%{
	"name" => "link.io",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)
	}
	]

	assert account_data["source"]["fields"] == [
	%{
	"name" => "<a href=\"http://google.com\">foo</a>",
	"value" => "<script>bar</script>"
	},
	%{"name" => "link.io", "value" => "cofe.io"}
	]
	end

	test "update fields with a link to content with rel=me, with ap id", %{user: user, conn: conn} do
	Tesla.Mock.mock(fn
	%{url: "http://example.com/rel_me/ap_id"} ->
	%Tesla.Env{
	status: 200,
	body: ~s[<html><head><link rel="me" href="#{user.ap_id}"></head></html>]
	}
	end)

	field = %{name: "Website", value: "http://example.com/rel_me/ap_id"}

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: [field]})
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"name" => "Website",
	"value" =>
	~s[<a href="http://example.com/rel_me/ap_id" rel="ugc">http://example.com/rel_me/ap_id</a>],
	"verified_at" => verified_at
	}
	] = account_data["fields"]

	{:ok, verified_at, _} = DateTime.from_iso8601(verified_at)
	assert DateTime.diff(DateTime.utc_now(), verified_at) < 10
	end

	test "update fields with a link to content with rel=me, with frontend path", %{
	user: user,
	conn: conn
	} do
	fe_url = "#{Pleroma.Web.Endpoint.url()}/#{user.nickname}"

	Tesla.Mock.mock(fn
	%{url: "http://example.com/rel_me/fe_path"} ->
	%Tesla.Env{
	status: 200,
	body: ~s[<html><head><link rel="me" href="#{fe_url}"></head></html>]
	}
	end)

	field = %{name: "Website", value: "http://example.com/rel_me/fe_path"}

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: [field]})
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"name" => "Website",
	"value" =>
	~s[<a href="http://example.com/rel_me/fe_path" rel="ugc">http://example.com/rel_me/fe_path</a>],
	"verified_at" => verified_at
	}
	] = account_data["fields"]

	{:ok, verified_at, _} = DateTime.from_iso8601(verified_at)
	assert DateTime.diff(DateTime.utc_now(), verified_at) < 10
	end

	test "emojis in fields labels", %{conn: conn} do
	fields = [
	%{name: ":firefox:", value: "is best 2hu"},
	%{name: "they wins", value: ":blank:"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	assert account_data["source"]["fields"] == [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = account_data["emojis"]
	end

	test "update fields via x-www-form-urlencoded", %{conn: conn} do
	fields =
	[
	"fields_attributes[1][name]=link",
	"fields_attributes[1][value]=http://cofe.io",
	"fields_attributes[0][name]=foo",
	"fields_attributes[0][value]=bar"
	]
	\|> Enum.join("&")

	account =
	conn
	\|> put_req_header("content-type", "application/x-www-form-urlencoded")
	\|> patch("/api/v1/accounts/update_credentials", fields)
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{
	"name" => "link",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">http://cofe.io</a>)
	}
	]

	assert account["source"]["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "http://cofe.io"}
	]
	end

	test "update fields with empty name", %{conn: conn} do
	fields = [
	%{name: "foo", value: ""},
	%{name: "", value: "bar"}
	]

	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => ""}
	]
	end

	test "update fields when invalid request", %{conn: conn} do
	name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
	value_limit = Pleroma.Config.get([:instance, :account_field_value_length])

	long_name = Enum.map(0..name_limit, fn _ -> "x" end) \|> Enum.join()
	long_value = Enum.map(0..value_limit, fn _ -> "x" end) \|> Enum.join()

	fields = [%{name: "foo", value: long_value}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
	\|> json_response_and_validate_schema(403)

	fields = [%{name: long_name, value: "bar"}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
	\|> json_response_and_validate_schema(403)

	clear_config([:instance, :max_account_fields], 1)

	fields = [
	%{name: "foo", value: "bar"},
	%{"name" => "link", "value" => "cofe.io"}
	]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
	\|> json_response_and_validate_schema(403)
	end
	end

	describe "Mark account as bot" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "changing actor_type to Service makes account a bot", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Service"})
	\|> json_response_and_validate_schema(200)

	assert account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Service"
	end

	test "changing actor_type to Person makes account a human", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Person"})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end

	test "changing actor_type to Application causes error", %{conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Application"})
	\|> json_response_and_validate_schema(403)

	assert %{"error" => "Invalid request"} == response
	end

	test "changing bot field to true changes actor_type to Service", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{bot: "true"})
	\|> json_response_and_validate_schema(200)

	assert account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Service"
	end

	test "changing bot field to false changes actor_type to Person", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{bot: "false"})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end

	test "actor_type field has a higher priority than bot", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{
	actor_type: "Person",
	bot: "true"
	})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end
	end

	describe "Updating direct message settings" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "changing to :everybody", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{
	accepts_direct_messages_from: "everybody"
	})
	\|> json_response_and_validate_schema(200)

	assert account["accepts_direct_messages_from"]
	assert account["accepts_direct_messages_from"] == "everybody"
	assert Pleroma.User.get_by_ap_id(account["url"]).accepts_direct_messages_from == :everybody
	end

	test "changing to :nobody", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{accepts_direct_messages_from: "nobody"})
	\|> json_response_and_validate_schema(200)

	assert account["accepts_direct_messages_from"]
	assert account["accepts_direct_messages_from"] == "nobody"
	assert Pleroma.User.get_by_ap_id(account["url"]).accepts_direct_messages_from == :nobody
	end

	test "changing to :people_i_follow", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{
	accepts_direct_messages_from: "people_i_follow"
	})
	\|> json_response_and_validate_schema(200)

	assert account["accepts_direct_messages_from"]
	assert account["accepts_direct_messages_from"] == "people_i_follow"

	assert Pleroma.User.get_by_ap_id(account["url"]).accepts_direct_messages_from ==
	:people_i_follow
	end

	test "changing to an unsupported value", %{conn: conn} do
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{
	accepts_direct_messages_from: "unsupported"
	})
	\|> json_response(400)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/account_view_test.exs b/test/pleroma/web/mastodon_api/views/account_view_test.exs
	index 192af936a..5b8aea8ac 100644
	--- a/test/pleroma/web/mastodon_api/views/account_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/account_view_test.exs
	@@ -1,725 +1,726 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	:ok
	end

	test "Represent a user account" do
	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	ap_id: "https://example.com/users/chikichikibanban",
	follower_count: 3,
	note_count: 5,
	background: background_image,
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio:
	"<script src=\"invalid-html\"></script><span>valid html</span>. a<br>b<br/>c<br >d<br />f '&<>\"",
	inserted_at: ~N[2017-08-15 15:47:06.597036],
	emoji: %{"karjalanpiirakka" => "/file.png"},
	raw_bio: "valid html. a\nb\nc\nd\nf '&<>\"",
	also_known_as: ["https://shitposter.zone/users/shp"],
	status_ttl_days: 5
	})

	insert(:instance, %{host: "example.com", nodeinfo: %{version: "2.1"}})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>. a<br/>b<br/>c<br/>d<br/>f '&<>"",
	url: user.ap_id,
	akkoma: %{
	instance: %{
	name: "example.com",
	nodeinfo: %{
	"version" => "2.1"
	},
	favicon: nil
	},
	status_ttl_days: 5
	},
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	static_url: "/file.png",
	url: "/file.png",
	shortcode: "karjalanpiirakka",
	visible_in_picker: false
	}
	],
	fields: [],
	bot: false,
	source: %{
	note: "valid html. a\nb\nc\nd\nf '&<>\"",
	sensitive: false,
	pleroma: %{
	actor_type: "Person",
	discoverable: true
	},
	fields: []
	},
	fqn: "shp@shitposter.club",
	last_status_at: nil,
	pleroma: %{
	ap_id: user.ap_id,
	also_known_as: ["https://shitposter.zone/users/shp"],
	background_image: "https://example.com/images/asuka_hospital.png",
	favicon: nil,
	is_confirmed: true,
	tags: [],
	is_admin: false,
	is_moderator: false,
	is_suggested: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	describe "nodeinfo" do
	setup do
	[
	user: insert(:user, ap_id: "https://somewhere.example.com/users/chikichikibanban"),
	instance:
	insert(:instance, %{
	host: "somewhere.example.com",
	favicon: "https://example.com/favicon.ico"
	})
	]
	end

	test "is embedded in the account view", %{user: user} do
	assert %{
	akkoma: %{
	instance: %{
	name: "somewhere.example.com",
	nodeinfo: %{
	"version" => "2.0"
	},
	favicon: "https://example.com/favicon.ico"
	}
	}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "uses local nodeinfo for local users" do
	user = insert(:user)

	assert %{
	akkoma: %{
	instance: %{
	name: "localhost",
	nodeinfo: %{
	software: %{
	name: "akkoma"
	}
	}
	}
	}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end
	end

	describe "favicon" do
	setup do
	[
	user: insert(:user, ap_id: "https://example.com/users/chikichikibanban"),
	instance:
	insert(:instance, %{host: "example.com", favicon: "https://example.com/favicon.ico"})
	]
	end

	test "is parsed when :instance_favicons is enabled", %{user: user} do
	clear_config([:instances_favicons, :enabled], true)

	assert %{
	pleroma: %{
	favicon: "https://example.com/favicon.ico"
	}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "is nil when we have no instance", %{user: user} do
	user = %{user \| ap_id: "https://wowee.example.com/users/2"}

	assert %{pleroma: %{favicon: nil}} =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %{
	block_from_strangers: false,
	hide_notification_contents: false
	}

	privacy = user.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings, allow_following_move: true},
	source: %{privacy: ^privacy}
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	actor_type: "Service",
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	actor_type: "Service",
	discoverable: true
	},
	fields: []
	},
	fqn: "shp@shitposter.club",
	last_status_at: nil,
	akkoma: %{
	instance: %{
	name: "localhost",
	favicon: "http://localhost:4001/favicon.png",
	nodeinfo: %{version: "2.0"}
	},
	status_ttl_days: nil
	},
	pleroma: %{
	ap_id: user.ap_id,
	also_known_as: [],
	background_image: nil,
	favicon: "http://localhost:4001/favicon.png",
	is_confirmed: true,
	tags: [],
	is_admin: false,
	is_moderator: false,
	is_suggested: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	with_mock(
	Pleroma.Web.Nodeinfo.Nodeinfo,
	get_nodeinfo: fn _ -> %{version: "2.0"} end
	) do
	assert expected ==
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end
	end

	test "Represent a Funkwhale channel" do
	{:ok, user} =
	User.get_or_fetch_by_ap_id(
	"https://channels.tests.funkwhale.audio/federation/actors/compositions"
	)

	assert represented =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert represented.acct == "compositions@channels.tests.funkwhale.audio"
	assert represented.url == "https://channels.tests.funkwhale.audio/channels/compositions"
	end

	test "Represent a deactivated user for an admin" do
	admin = insert(:user, is_admin: true)
	deactivated_user = insert(:user, is_active: false)
	represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	test "demands :for or :skip_visibility_check option for account rendering" do
	clear_config([:restrict_unauthenticated, :profiles, :local], false)

	user = insert(:user)
	user_id = user.id

	assert %{id: ^user_id} = AccountView.render("show.json", %{user: user, for: nil})
	assert %{id: ^user_id} = AccountView.render("show.json", %{user: user, for: user})

	assert %{id: ^user_id} =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert_raise RuntimeError, ~r/:skip_visibility_check or :for option is required/, fn ->
	AccountView.render("show.json", %{user: user})
	end
	end

	describe "relationship" do
	defp test_relationship_rendering(user, other_user, expected_result) do
	opts = %{user: user, target: other_user, relationships: nil}
	assert expected_result == AccountView.render("relationship.json", opts)

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
	opts = Map.put(opts, :relationships, relationships_opt)
	assert expected_result == AccountView.render("relationship.json", opts)

	assert [expected_result] ==
	AccountView.render("relationships.json", %{user: user, targets: [other_user]})
	end

	@blank_response %{
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	notifying: false,
	requested: false,
	requested_by: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false,
	note: ""
	}

	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user, other_user} = User.follow(user, other_user)
	{:ok, other_user, user} = User.follow(other_user, user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationships} = User.mute(user, other_user, %{notifications: true})
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, other_user)

	expected =
	Map.merge(
	@blank_response,
	%{
	following: true,
	followed_by: true,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	notifying: true,
	showing_reblogs: false,
	id: to_string(other_user.id)
	}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user, other_user} = User.follow(user, other_user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationship} = User.block(user, other_user)
	{:ok, _user_relationship} = User.block(other_user, user)

	expected =
	Map.merge(
	@blank_response,
	%{following: false, blocking: true, blocked_by: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "blocks are not visible to the blocked user" do
	user = insert(:user)
	other_user = insert(:user)

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

	expected =
	Map.merge(
	@blank_response,
	%{following: false, blocking: false, blocked_by: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	expected =
	Map.merge(
	@blank_response,
	%{domain_blocking: true, blocking: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, is_locked: true)

	{:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected =
	Map.merge(
	@blank_response,
	%{requested: true, following: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end
	end

	test "represent a relationship for a user with an inbound pending follow request" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)

	follower = User.get_cached_by_id(follower.id)
	followed = User.get_cached_by_id(followed.id)

	expected =
	Map.merge(
	@blank_response,
	%{requested_by: true, followed_by: false, id: to_string(follower.id)}
	)

	test_relationship_rendering(followed, follower, expected)
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, pleroma_settings_store: %{fe: "test"})

	result =
	AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("show.json", %{user: user, for: nil, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("show.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "doesn't sanitize display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	assert result.display_name == "<marquee> username </marquee>"
	end

	test "never display nil user follow counts" do
	user = insert(:user, following_count: 0, follower_count: 0)
	result = AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert result.following_count == 0
	assert result.followers_count == 0
	end

	describe "hiding follows/following" do
	test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
	user =
	insert(:user, %{
	hide_followers: true,
	hide_followers_count: true,
	hide_follows: true,
	hide_follows_count: true
	})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows_count: true, hide_followers_count: true}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "shows when follows/followers are hidden" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)

	assert User.following?(user, other_user)
	assert Pleroma.FollowingRelationship.follower_count(other_user) == 1
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows unread_conversation_count only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(other_user, %{
	status: "Hey @#{user.nickname}.",
	visibility: "direct"
	})

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
	:unread_conversation_count
	] == nil

	assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
	:unread_conversation_count
	] == 1
	end

	test "shows unread_count only to the account owner" do
	user = insert(:user)
	insert_list(7, :notification, user: user, activity: insert(:note_activity))
	other_user = insert(:user)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: other_user}
	)[:pleroma][:unread_notifications_count] == nil

	assert AccountView.render(
	"show.json",
	%{user: user, for: user}
	)[:pleroma][:unread_notifications_count] == 7
	end

	test "shows email only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: other_user}
	)[:pleroma][:email] == nil

	assert AccountView.render(
	"show.json",
	%{user: user, for: user}
	)[:pleroma][:email] == user.email
	end
	end

	describe "follow requests counter" do
	test "shows zero when no follow requests are pending" do
	user = insert(:user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when follow requests are pending" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when accepting a follow request" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when rejecting a follow request" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when historical unapproved requests are present" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	{:ok, user} = User.update_and_set_cache(user, %{is_locked: false})

	assert %{locked: false, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end
	end

	test "uses mediaproxy urls when it's enabled (regardless of media preview proxy state)" do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled])

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://evil.website/avatar.png"}]},
	banner: %{"url" => [%{"href" => "https://evil.website/banner.png"}]},
	emoji: %{"joker_smile" => "https://evil.website/society.png"}
	)

	insert(:instance, %{host: "localhost", favicon: "https://evil.website/favicon.png"})

	with media_preview_enabled <- [false, true] do
	clear_config([:media_preview_proxy, :enabled], media_preview_enabled)

	AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	\|> Enum.all?(fn
	{key, url} when key in [:avatar, :avatar_static, :header, :header_static] ->
	String.starts_with?(url, Pleroma.Web.Endpoint.url())

	{:akkoma, %{instance: %{favicon: favicon_url}}} ->
	String.starts_with?(favicon_url, Pleroma.Web.Endpoint.url())

	{:emojis, emojis} ->
	Enum.all?(emojis, fn %{url: url, static_url: static_url} ->
	String.starts_with?(url, Pleroma.Web.Endpoint.url()) &&
	String.starts_with?(static_url, Pleroma.Web.Endpoint.url())
	end)

	_ ->
	true
	end)
	\|> assert()
	end
	end

	test "returns nil in the instance field when no instance is held locally" do
	user = insert(:user, ap_id: "https://example.com/users/1")
	view = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	assert view[:akkoma][:instance] == nil
	end
	end
	diff --git a/test/pleroma/web/media_proxy/invalidation_test.exs b/test/pleroma/web/media_proxy/invalidation_test.exs
	index ac62ba3e7..b10e2271b 100644
	--- a/test/pleroma/web/media_proxy/invalidation_test.exs
	+++ b/test/pleroma/web/media_proxy/invalidation_test.exs
	@@ -1,62 +1,63 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.InvalidationTest do
	use Pleroma.DataCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Web.MediaProxy.Invalidation

	import ExUnit.CaptureLog
	import Mock
	import Tesla.Mock

	setup do: clear_config([:media_proxy])

	describe "Invalidation.Http" do
	test "perform request to clear cache" do
	clear_config([:media_proxy, :enabled], false)
	clear_config([:media_proxy, :invalidation, :enabled], true)
	clear_config([:media_proxy, :invalidation, :provider], Invalidation.Http)

	clear_config([Invalidation.Http], method: :purge, headers: [{"x-refresh", 1}])
	image_url = "http://example.com/media/example.jpg"
	Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)

	mock(fn
	%{
	method: :purge,
	url: "http://example.com/media/example.jpg",
	headers: [{"x-refresh", 1}]
	} ->
	%Tesla.Env{status: 200}
	end)

	assert capture_log(fn ->
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	assert Invalidation.purge([image_url]) == {:ok, [image_url]}
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	end) =~ "Running cache purge: [\"#{image_url}\"]"
	end
	end

	describe "Invalidation.Script" do
	test "run script to clear cache" do
	clear_config([:media_proxy, :enabled], false)
	clear_config([:media_proxy, :invalidation, :enabled], true)
	clear_config([:media_proxy, :invalidation, :provider], Invalidation.Script)
	clear_config([Invalidation.Script], script_path: "purge-nginx")

	image_url = "http://example.com/media/example.jpg"
	Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)

	with_mocks [{System, [], [cmd: fn _, _ -> {"ok", 0} end]}] do
	assert capture_log(fn ->
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	assert Invalidation.purge([image_url]) == {:ok, [image_url]}
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	end) =~ "Running cache purge: [\"#{image_url}\"]"
	end
	end
	end
	end
	diff --git a/test/pleroma/web/media_proxy/media_proxy_controller_test.exs b/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	index 64287c4bd..30c144917 100644
	--- a/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	+++ b/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	@@ -1,340 +1,341 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.MediaProxyControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import Mock

	alias Pleroma.Web.MediaProxy
	alias Plug.Conn

	setup do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	end

	describe "Media Proxy" do
	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	[url: MediaProxy.encode_url("https://google.fn/test.png")]
	end

	test "it returns 404 when disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "it performs ReverseProxy.call with valid signature", %{conn: conn, url: url} do
	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: :success} = get(conn, url)
	end
	end

	test "it returns 404 when url is in banned_urls cache", %{conn: conn, url: url} do
	MediaProxy.put_in_banned_urls("https://google.fn/test.png")

	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: 404, resp_body: "Not Found"} = get(conn, url)
	end
	end
	end

	describe "Media Preview Proxy" do
	def assert_dependencies_installed do
	missing_dependencies = Pleroma.Helpers.MediaHelper.missing_dependencies()

	assert missing_dependencies == [],
	"Error: missing dependencies (please refer to `docs/installation`): #{inspect(missing_dependencies)}"
	end

	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	original_url = "https://google.fn/test.png"

	[
	url: MediaProxy.encode_preview_url(original_url),
	media_proxy_url: MediaProxy.encode_url(original_url)
	]
	end

	test "returns 404 when media proxy is disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "returns 404 when disabled", %{conn: conn} do
	clear_config([:media_preview_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "responds with 424 Failed Dependency if HEAD request to media proxy fails", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	response = get(conn, url)
	assert response.status == 424
	assert response.resp_body == "Can't fetch HTTP headers (HTTP 500)."
	end

	test "redirects to media proxy URI on unsupported content type", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "application/pdf"}]}
	end)

	response = get(conn, url)
	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static=true` and GIF image preview requested, responds with JPEG image", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	# Setting a high :min_content_length to ensure this scenario is not affected by its logic
	clear_config([:media_preview_proxy, :min_content_length], 1_000_000_000)

	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "1001718"}]
	}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.gif")}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "with GIF image preview requested and no `static` param, redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/gif"}]}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static` param and non-GIF image preview requested, " <>
	"redirects to media preview proxy URI without `static` param",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "with :min_content_length setting not matched by Content-Length header, " <>
	"redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	clear_config([:media_preview_proxy, :min_content_length], 100_000)

	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "5000"}]
	}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "thumbnails PNG images into PNG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/png"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.png")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/png"]
	assert response.resp_body != ""
	end

	test "thumbnails JPEG images into JPEG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.jpg")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "redirects to media proxy URI in case of thumbnailing error", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "<html><body>error</body></html>"}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end
	end
	end
	diff --git a/test/pleroma/web/o_auth/ldap_authorization_test.exs b/test/pleroma/web/o_auth/ldap_authorization_test.exs
	index 1bca3c35e..136e4edb2 100644
	--- a/test/pleroma/web/o_auth/ldap_authorization_test.exs
	+++ b/test/pleroma/web/o_auth/ldap_authorization_test.exs
	@@ -1,135 +1,136 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.LDAPAuthorizationTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.Token
	import Pleroma.Factory
	import Mock

	@skip if !Code.ensure_loaded?(:eldap), do: :skip

	setup_all do: clear_config([:ldap, :enabled], true)

	setup_all do: clear_config(Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.LDAPAuthenticator)

	@tag @skip
	test "authorizes the existing user using LDAP credentials" do
	password = "testpassword"
	user = insert(:user, password_hash: Pleroma.Password.hash_pwd_salt(password))
	app = insert(:oauth_app, scopes: ["read", "write"])

	host = Pleroma.Config.get([:ldap, :host]) \|> to_charlist
	port = Pleroma.Config.get([:ldap, :port])

	with_mocks [
	{:eldap, [],
	[
	open: fn [^host], [{:port, ^port}, {:ssl, false} \| _] -> {:ok, self()} end,
	simple_bind: fn _connection, _dn, ^password -> :ok end,
	close: fn _connection ->
	send(self(), :close_connection)
	:ok
	end
	]}
	] do
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)

	assert token.user_id == user.id
	assert_receive :close_connection
	end
	end

	@tag @skip
	test "creates a new user after successful LDAP authorization" do
	password = "testpassword"
	user = build(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	host = Pleroma.Config.get([:ldap, :host]) \|> to_charlist
	port = Pleroma.Config.get([:ldap, :port])

	with_mocks [
	{:eldap, [],
	[
	open: fn [^host], [{:port, ^port}, {:ssl, false} \| _] -> {:ok, self()} end,
	simple_bind: fn _connection, _dn, ^password -> :ok end,
	equalityMatch: fn _type, _value -> :ok end,
	wholeSubtree: fn -> :ok end,
	search: fn _connection, _options ->
	{:ok, {:eldap_search_result, [{:eldap_entry, ~c"", []}], [], []}}
	end,
	close: fn _connection ->
	send(self(), :close_connection)
	:ok
	end
	]}
	] do
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token) \|> Repo.preload(:user)

	assert token.user.nickname == user.nickname
	assert_receive :close_connection
	end
	end

	@tag @skip
	test "disallow authorization for wrong LDAP credentials" do
	password = "testpassword"
	user = insert(:user, password_hash: Pleroma.Password.hash_pwd_salt(password))
	app = insert(:oauth_app, scopes: ["read", "write"])

	host = Pleroma.Config.get([:ldap, :host]) \|> to_charlist
	port = Pleroma.Config.get([:ldap, :port])

	with_mocks [
	{:eldap, [],
	[
	open: fn [^host], [{:port, ^port}, {:ssl, false} \| _] -> {:ok, self()} end,
	simple_bind: fn _connection, _dn, ^password -> {:error, :invalidCredentials} end,
	close: fn _connection ->
	send(self(), :close_connection)
	:ok
	end
	]}
	] do
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"error" => "Invalid credentials"} = json_response(conn, 400)
	assert_receive :close_connection
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/emoji_file_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/emoji_file_controller_test.exs
	index ceff6eaa5..78ca5098f 100644
	--- a/test/pleroma/web/pleroma_api/controllers/emoji_file_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/emoji_file_controller_test.exs
	@@ -1,382 +1,383 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiFileControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import Mock
	import Tesla.Mock
	import Pleroma.Factory

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)
	setup do: clear_config([:instance, :public], true)

	setup do
	File.mkdir_p!(@emoji_path)
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	admin_conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	Pleroma.Emoji.reload()
	{:ok, %{admin_conn: admin_conn}}
	end

	describe "POST/PATCH/DELETE /api/v1/pleroma/emoji/packs/files?name=:name" do
	setup do
	pack_file = "#{@emoji_path}/test_pack/pack.json"
	original_content = File.read!(pack_file)

	on_exit(fn ->
	File.write!(pack_file, original_content)
	end)

	:ok
	end

	test "upload zip file with emojis", %{admin_conn: admin_conn} do
	on_exit(fn ->
	[
	"128px/a_trusted_friend-128.png",
	"auroraborealis.png",
	"1000px/baby_in_a_box.png",
	"1000px/bear.png",
	"128px/bear-128.png"
	]
	\|> Enum.each(fn path -> File.rm_rf!("#{@emoji_path}/test_pack/#{path}") end)
	end)

	resp =
	admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	file: %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}
	})
	\|> json_response_and_validate_schema(200)

	assert resp == %{
	"a_trusted_friend-128" => "128px/a_trusted_friend-128.png",
	"auroraborealis" => "auroraborealis.png",
	"baby_in_a_box" => "1000px/baby_in_a_box.png",
	"bear" => "1000px/bear.png",
	"bear-128" => "128px/bear-128.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	Enum.each(Map.values(resp), fn path ->
	assert File.exists?("#{@emoji_path}/test_pack/#{path}")
	end)
	end

	test "create shortcode exists", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" => "An emoji with the \"blank\" shortcode already exists"
	}
	end

	test "don't rewrite old emoji", %{admin_conn: admin_conn} do
	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png",
	"blank3" => "dir/blank.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank",
	new_shortcode: "blank2",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" =>
	"New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
	}
	end

	test "rewrite old emoji with force option", %{admin_conn: admin_conn} do
	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir_2/") end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png",
	"blank3" => "dir/blank.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	new_shortcode: "blank4",
	new_filename: "dir_2/blank_3.png",
	force: true
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png",
	"blank4" => "dir_2/blank_3.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
	end

	test "with empty filename", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank2",
	filename: "",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(422) == %{
	"error" => "pack name, shortcode or filename cannot be empty"
	}
	end

	test "add file with not loaded pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=not_loaded", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "returns an error on add file when file system is not writable", %{
	admin_conn: admin_conn
	} do
	pack_file = Path.join([@emoji_path, "not_loaded", "pack.json"])

	with_mocks([
	{File, [:passthrough], [stat: fn ^pack_file -> {:error, :eacces} end]}
	]) do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=not_loaded", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(500) == %{
	"error" =>
	"Unexpected error occurred while adding file to pack. (POSIX error: Permission denied)"
	}
	end
	end

	test "remove file with not loaded pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/packs/files?name=not_loaded&shortcode=blank3")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "remove file with empty shortcode", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/packs/files?name=not_loaded&shortcode=")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "update file with not loaded pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/packs/files?name=not_loaded", %{
	shortcode: "blank4",
	new_shortcode: "blank3",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "new with shortcode as file with update", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank4",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank4" => "dir/blank.png",
	"blank2" => "blank2.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank4",
	new_shortcode: "blank3",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank3" => "dir_2/blank_3.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	refute File.exists?("#{@emoji_path}/test_pack/dir/")
	assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")

	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	refute File.exists?("#{@emoji_path}/test_pack/dir_2/")

	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
	end

	test "new with shortcode from url", %{admin_conn: admin_conn} do
	mock(fn
	%{
	method: :get,
	url: "https://test-blank/blank_url.png"
	} ->
	text(File.read!("#{@emoji_path}/test_pack/blank.png"))
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank_url",
	file: "https://test-blank/blank_url.png"
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank_url" => "blank_url.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")

	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/blank_url.png") end)
	end

	test "new without shortcode", %{admin_conn: admin_conn} do
	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/shortcode.png") end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	file: %Plug.Upload{
	filename: "shortcode.png",
	path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"shortcode" => "shortcode.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}
	end

	test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "Emoji \"blank3\" does not exist"
	}
	end

	test "update non existing emoji", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	new_shortcode: "blank4",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "Emoji \"blank3\" does not exist"
	}
	end

	test "update with empty shortcode", %{admin_conn: admin_conn} do
	assert %{
	"error" => "Missing field: new_shortcode."
	} =
	admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:bad_request)
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	index 95498d412..b773370d8 100644
	--- a/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	@@ -1,709 +1,710 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import Mock
	import Tesla.Mock
	import Pleroma.Factory

	@static_dir Pleroma.Config.get!([:instance, :static_dir])
	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	setup do: clear_config([:instance, :public], true)
	setup do: clear_config([:instance, :static_dir], @static_dir)

	setup do
	File.mkdir_p!(@emoji_path)
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	admin_conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	Pleroma.Emoji.reload()
	{:ok, %{admin_conn: admin_conn}}
	end

	test "GET /api/v1/pleroma/emoji/packs when :public: false", %{conn: conn} do
	clear_config([:instance, :public], false)
	conn \|> get("/api/v1/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	end

	test "GET /api/v1/pleroma/emoji/packs", %{conn: conn} do
	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 5

	assert resp["packs"]
	\|> Map.keys()
	\|> length() == 5

	shared = resp["packs"]["test_pack"]
	assert shared["files"] == %{"blank" => "blank.png", "blank2" => "blank2.png"}
	assert Map.has_key?(shared["pack"], "download-sha256")
	assert shared["pack"]["can-download"]
	assert shared["pack"]["share-files"]

	non_shared = resp["packs"]["test_pack_nonshared"]
	assert non_shared["pack"]["share-files"] == false
	assert non_shared["pack"]["can-download"] == false

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs?page_size=1")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 5

	packs = Map.keys(resp["packs"])

	assert length(packs) == 1

	[pack1] = packs

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs?page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 5
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack2] = packs

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs?page_size=1&page=3")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 5
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack3] = packs

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs?page_size=1&page=4")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 5
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack4] = packs
	assert [pack1, pack2, pack3, pack4] \|> Enum.uniq() \|> length() == 4
	end

	describe "GET /api/v1/pleroma/emoji/packs/remote" do
	test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs?page=2&page_size=1")
	\|> json_response_and_validate_schema(200)

	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/packs?page=2&page_size=1"
	} ->
	json(resp)
	end)

	assert admin_conn
	\|> get(
	"/api/v1/pleroma/emoji/packs/remote?url=https://example.com&page=2&page_size=1"
	)
	\|> json_response_and_validate_schema(200) == resp
	end

	test "non shareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> get("/api/v1/pleroma/emoji/packs/remote?url=https://example.com")
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end
	end

	describe "GET /api/v1/pleroma/emoji/packs/archive?name=:name" do
	test "download shared pack", %{conn: conn} do
	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack")
	\|> response(200)

	{:ok, arch} = :zip.unzip(resp, [:memory])

	assert Enum.find(arch, fn {n, _} -> n == ~c"pack.json" end)
	assert Enum.find(arch, fn {n, _} -> n == ~c"blank.png" end)
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	\|> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack_for_import")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack test_pack_for_import does not exist"
	}
	end

	test "non downloadable pack", %{conn: conn} do
	assert conn
	\|> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack_nonshared")
	\|> json_response_and_validate_schema(:forbidden) == %{
	"error" =>
	"Pack test_pack_nonshared cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	}
	end
	end

	describe "POST /api/v1/pleroma/emoji/packs/download" do
	test "shared pack from remote and non shared from fallback-src", %{
	admin_conn: admin_conn,
	conn: conn
	} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack"
	} ->
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=test_pack"
	} ->
	conn
	\|> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack")
	\|> response(200)
	\|> text()

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack_nonshared"
	} ->
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=test_pack_nonshared")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=test%20with%20spaces"
	} ->
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=test%20with%20spaces")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=test%20with%20spaces"
	} ->
	conn
	\|> get("/api/v1/pleroma/emoji/packs/archive?name=test%20with%20spaces")
	\|> response(200)
	\|> text()
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack2/blank.png")

	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/pack?name=test_pack2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack2")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/v1/pleroma/emoji/packs/download",
	%{
	url: "https://example.com",
	name: "test_pack_nonshared",
	as: "test_pack_nonshared2"
	}
	)
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")

	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/pack?name=test_pack_nonshared2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack_nonshared2")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test with spaces",
	as: "test with spaces"
	})
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test with spaces/pack.json")
	assert File.exists?("#{@emoji_path}/test with spaces/blank.png")
	end

	test "nonshareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/v1/pleroma/emoji/packs/download",
	%{
	url: "https://old-instance",
	name: "test_pack",
	as: "test_pack2"
	}
	)
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end

	test "checksum fail", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=pack_bad_sha"
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=pack_bad_sha"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
	}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "pack_bad_sha",
	as: "pack_bad_sha2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" => "SHA256 for the pack doesn't match the one sent by the server"
	}
	end

	test "other error", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack"
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" =>
	"The pack was not set as shared and there is no fallback src to download from"
	}
	end
	end

	describe "PATCH/update /api/v1/pleroma/emoji/pack?name=:name" do
	setup do
	pack_file = "#{@emoji_path}/test_pack/pack.json"
	original_content = File.read!(pack_file)

	on_exit(fn ->
	File.write!(pack_file, original_content)
	end)

	{:ok,
	pack_file: pack_file,
	new_data: %{
	"license" => "Test license changed",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"share-files" => false
	}}
	end

	test "returns error when file system not writable", %{admin_conn: conn} = ctx do
	with_mocks([
	{File, [:passthrough], [stat: fn _ -> {:error, :eacces} end]}
	]) do
	assert conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch(
	"/api/v1/pleroma/emoji/pack?name=test_pack",
	%{"metadata" => ctx[:new_data]}
	)
	\|> json_response_and_validate_schema(500)
	end
	end

	test "for a pack without a fallback source", ctx do
	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/pack?name=test_pack", %{
	"metadata" => ctx[:new_data]
	})
	\|> json_response_and_validate_schema(200) == ctx[:new_data]

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
	end

	test "for a pack with a fallback source", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	new_data_with_sha =
	Map.put(
	new_data,
	"fallback-src-sha256",
	"1967BB4E42BCC34BCC12D57BE7811D3B7BE52F965BCE45C87BD377B9499CE11D"
	)

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(200) == new_data_with_sha

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
	end

	test "when the fallback source doesn't have all the files", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	{:ok, {~c"empty.zip", empty_arch}} = :zip.zip(~c"empty.zip", [], [:memory])
	text(empty_arch)
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/v1/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "The fallback archive does not have all files specified in pack.json"
	}
	end
	end

	describe "POST/DELETE /api/v1/pleroma/emoji/pack?name=:name" do
	test "returns an error on creates pack when file system not writable", %{
	admin_conn: admin_conn
	} do
	path_pack = Path.join(@emoji_path, "test_pack")

	with_mocks([
	{File, [:passthrough], [mkdir: fn ^path_pack -> {:error, :eacces} end]}
	]) do
	assert admin_conn
	\|> post("/api/v1/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(500) == %{
	"error" =>
	"Unexpected error occurred while creating pack. (POSIX error: Permission denied)"
	}
	end
	end

	test "returns an error on deletes pack when the file system is not writable", %{
	admin_conn: admin_conn
	} do
	path_pack = Path.join(@emoji_path, "test_emoji_pack")

	try do
	{:ok, _pack} = Pleroma.Emoji.Pack.create("test_emoji_pack")

	with_mocks([
	{File, [:passthrough], [rm_rf: fn ^path_pack -> {:error, :eacces, path_pack} end]}
	]) do
	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/pack?name=test_emoji_pack")
	\|> json_response_and_validate_schema(500) == %{
	"error" =>
	"Couldn't delete the `test_emoji_pack` pack (POSIX error: Permission denied)"
	}
	end
	after
	File.rm_rf(path_pack)
	end
	end

	test "creating and deleting a pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> post("/api/v1/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_created/pack.json")

	assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
	"pack" => %{},
	"files" => %{},
	"files_count" => 0
	}

	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_created/pack.json")
	end

	test "if pack exists", %{admin_conn: admin_conn} do
	path = Path.join(@emoji_path, "test_created")
	File.mkdir(path)
	pack_file = Jason.encode!(%{files: %{}, pack: %{}})
	File.write!(Path.join(path, "pack.json"), pack_file)

	assert admin_conn
	\|> post("/api/v1/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" => "A pack named \"test_created\" already exists"
	}

	on_exit(fn -> File.rm_rf(path) end)
	end

	test "with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> post("/api/v1/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end

	test "deleting nonexisting pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/pack?name=non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "deleting with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/v1/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end

	test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
	on_exit(fn ->
	File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	end)

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs")
	\|> json_response_and_validate_schema(200)

	refute Map.has_key?(resp["packs"], "test_pack_for_import")

	assert admin_conn
	\|> get("/api/v1/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs")
	\|> json_response_and_validate_schema(200)

	assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}

	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")

	emoji_txt_content = """
	blank, blank.png, Fun
	blank2, blank.png
	foo, /emoji/test_pack_for_import/blank.png
	bar
	"""

	File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)

	assert admin_conn
	\|> get("/api/v1/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp =
	conn
	\|> get("/api/v1/pleroma/emoji/packs")
	\|> json_response_and_validate_schema(200)

	assert resp["packs"]["test_pack_for_import"]["files"] == %{
	"blank" => "blank.png",
	"blank2" => "blank.png",
	"foo" => "blank.png"
	}
	end

	describe "GET /api/v1/pleroma/emoji/pack?name=:name" do
	test "shows pack.json", %{conn: conn} do
	assert %{
	"files" => files,
	"files_count" => 2,
	"pack" => %{
	"can-download" => true,
	"description" => "Test description",
	"download-sha256" => _,
	"homepage" => "https://pleroma.social",
	"license" => "Test license",
	"share-files" => true
	}
	} =
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(200)

	assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=test_pack&page_size=1")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=test_pack&page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1
	end

	test "for pack name with special chars", %{conn: conn} do
	assert %{
	"files" => _files,
	"files_count" => 1,
	"pack" => %{
	"can-download" => true,
	"description" => "Test description",
	"download-sha256" => _,
	"homepage" => "https://pleroma.social",
	"license" => "Test license",
	"share-files" => true
	}
	} =
	conn
	\|> get("/api/v1/pleroma/emoji/pack?name=blobs.gg")
	\|> json_response_and_validate_schema(200)
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	\|> get("/api/v1/pleroma/emoji/pack?name=non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "error name", %{conn: conn} do
	assert conn
	\|> get("/api/v1/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs
	index 701ff6a84..3f3dc1d38 100644
	--- a/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs
	@@ -1,235 +1,236 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.UserImportControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Tests.ObanHelpers

	import Pleroma.Factory
	import Mock

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

	describe "POST /api/pleroma/follow_import" do
	setup do: oauth_access(["follow"])

	test "it returns HTTP 200", %{conn: conn} do
	user2 = insert(:user)

	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/follow_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response_and_validate_schema(200)
	end

	test "it imports follow lists from file", %{conn: conn} do
	user2 = insert(:user)

	with_mocks([
	{File, [],
	read!: fn "follow_list.txt" ->
	"Account address,Show boosts\n#{user2.ap_id},true"
	end}
	]) do
	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/follow_import", %{
	"list" => %Plug.Upload{path: "follow_list.txt"}
	})
	\|> json_response_and_validate_schema(200)

	assert [{:ok, job_result}] = ObanHelpers.perform_all()
	assert job_result == refresh_record(user2)
	assert %Pleroma.User{follower_count: 1} = job_result
	end
	end

	test "it imports new-style mastodon follow lists", %{conn: conn} do
	user2 = insert(:user)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/follow_import", %{
	"list" => "Account address,Show boosts\n#{user2.ap_id},true"
	})
	\|> json_response_and_validate_schema(200)

	assert response == "job started"
	end

	test "requires 'follow' or 'write:follows' permissions" do
	token1 = insert(:oauth_token, scopes: ["read", "write"])
	token2 = insert(:oauth_token, scopes: ["follow"])
	token3 = insert(:oauth_token, scopes: ["something"])
	another_user = insert(:user)

	for token <- [token1, token2, token3] do
	conn =
	build_conn()
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})

	if token == token3 do
	assert %{"error" => "Insufficient permissions: follow \| write:follows."} ==
	json_response(conn, 403)
	else
	assert json_response_and_validate_schema(conn, 200)
	end
	end
	end

	test "it imports follows with different nickname variations", %{conn: conn} do
	users = [user2, user3, user4, user5, user6] = insert_list(5, :user)

	identifiers =
	[
	user2.ap_id,
	user3.nickname,
	" ",
	"@" <> user4.nickname,
	user5.nickname <> "@localhost",
	"@" <> user6.nickname <> "@localhost"
	]
	\|> Enum.join("\n")

	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/follow_import", %{"list" => identifiers})
	\|> json_response_and_validate_schema(200)

	job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
	assert job_results == Enum.map(users, &refresh_record/1)
	end
	end

	describe "POST /api/pleroma/blocks_import" do
	# Note: "follow" or "write:blocks" permission is required
	setup do: oauth_access(["write:blocks"])

	test "it returns HTTP 200", %{conn: conn} do
	user2 = insert(:user)

	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response_and_validate_schema(200)
	end

	test "it imports blocks users from file", %{conn: conn} do
	users = [user2, user3] = insert_list(2, :user)

	with_mocks([
	{File, [], read!: fn "blocks_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
	]) do
	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/blocks_import", %{
	"list" => %Plug.Upload{path: "blocks_list.txt"}
	})
	\|> json_response_and_validate_schema(200)

	job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
	assert job_results == users
	end
	end

	test "it imports blocks with different nickname variations", %{conn: conn} do
	users = [user2, user3, user4, user5, user6] = insert_list(5, :user)

	identifiers =
	[
	user2.ap_id,
	user3.nickname,
	"@" <> user4.nickname,
	user5.nickname <> "@localhost",
	"@" <> user6.nickname <> "@localhost"
	]
	\|> Enum.join(" ")

	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/blocks_import", %{"list" => identifiers})
	\|> json_response_and_validate_schema(200)

	job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
	assert job_results == users
	end
	end

	describe "POST /api/pleroma/mutes_import" do
	# Note: "follow" or "write:mutes" permission is required
	setup do: oauth_access(["write:mutes"])

	test "it returns HTTP 200", %{user: user, conn: conn} do
	user2 = insert(:user)

	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/mutes_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response_and_validate_schema(200)

	job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
	assert job_results == [user2]
	assert Pleroma.User.mutes?(user, user2)
	end

	test "it imports muted users from file", %{user: user, conn: conn} do
	users = [user2, user3] = insert_list(2, :user)

	with_mocks([
	{File, [], read!: fn "mutes_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
	]) do
	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/mutes_import", %{
	"list" => %Plug.Upload{path: "mutes_list.txt"}
	})
	\|> json_response_and_validate_schema(200)

	job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
	assert job_results == users
	assert Enum.all?(users, &Pleroma.User.mutes?(user, &1))
	end
	end

	test "it imports mutes with different nickname variations", %{user: user, conn: conn} do
	users = [user2, user3, user4, user5, user6] = insert_list(5, :user)

	identifiers =
	[
	user2.ap_id,
	user3.nickname,
	"@" <> user4.nickname,
	user5.nickname <> "@localhost",
	"@" <> user6.nickname <> "@localhost"
	]
	\|> Enum.join(" ")

	assert "job started" ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/mutes_import", %{"list" => identifiers})
	\|> json_response_and_validate_schema(200)

	job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
	assert job_results == users
	assert Enum.all?(users, &Pleroma.User.mutes?(user, &1))
	end
	end
	end
	diff --git a/test/pleroma/web/plugs/admin_secret_authentication_plug_test.exs b/test/pleroma/web/plugs/admin_secret_authentication_plug_test.exs
	index 783ab5aa9..7a52d47ea 100644
	--- a/test/pleroma/web/plugs/admin_secret_authentication_plug_test.exs
	+++ b/test/pleroma/web/plugs/admin_secret_authentication_plug_test.exs
	@@ -1,77 +1,78 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.AdminSecretAuthenticationPlugTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	import Mock
	import Pleroma.Factory

	alias Pleroma.Web.Plugs.AdminSecretAuthenticationPlug
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.PlugHelper
	alias Pleroma.Web.Plugs.RateLimiter

	test "does nothing if a user is assigned", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)

	ret_conn =
	conn
	\|> AdminSecretAuthenticationPlug.call(%{})

	assert conn == ret_conn
	end

	describe "when secret set it assigns an admin user" do
	setup do: clear_config([:admin_token])

	setup_with_mocks([{RateLimiter, [:passthrough], []}]) do
	:ok
	end

	test "with `admin_token` query parameter", %{conn: conn} do
	clear_config(:admin_token, "password123")

	conn =
	%{conn \| params: %{"admin_token" => "wrong_password"}}
	\|> AdminSecretAuthenticationPlug.call(%{})

	refute conn.assigns[:user]
	assert called(RateLimiter.call(conn, name: :authentication))

	conn =
	%{conn \| params: %{"admin_token" => "password123"}}
	\|> AdminSecretAuthenticationPlug.call(%{})

	assert conn.assigns[:user].is_admin
	assert conn.assigns[:token] == nil
	assert PlugHelper.plug_skipped?(conn, OAuthScopesPlug)
	end

	test "with `x-admin-token` HTTP header", %{conn: conn} do
	clear_config(:admin_token, "☕️")

	conn =
	conn
	\|> put_req_header("x-admin-token", "🥛")
	\|> AdminSecretAuthenticationPlug.call(%{})

	refute conn.assigns[:user]
	assert called(RateLimiter.call(conn, name: :authentication))

	conn =
	conn
	\|> put_req_header("x-admin-token", "☕️")
	\|> AdminSecretAuthenticationPlug.call(%{})

	assert conn.assigns[:user].is_admin
	assert conn.assigns[:token] == nil
	assert PlugHelper.plug_skipped?(conn, OAuthScopesPlug)
	end
	end
	end
	diff --git a/test/pleroma/web/plugs/frontend_static_plug_test.exs b/test/pleroma/web/plugs/frontend_static_plug_test.exs
	index 1dceacf28..c99d1a79b 100644
	--- a/test/pleroma/web/plugs/frontend_static_plug_test.exs
	+++ b/test/pleroma/web/plugs/frontend_static_plug_test.exs
	@@ -1,114 +1,115 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.FrontendStaticPlugTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	import Mock

	@dir "test/tmp/instance_static"

	setup do
	File.mkdir_p!(@dir)
	on_exit(fn -> File.rm_rf(@dir) end)
	end

	setup do: clear_config([:instance, :static_dir], @dir)
	setup do: clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	test "init will give a static plug config + the frontend type" do
	opts =
	[
	at: "/admin",
	frontend_type: :admin
	]
	\|> Pleroma.Web.Plugs.FrontendStatic.init()

	assert opts[:at] == ["admin"]
	assert opts[:frontend_type] == :admin
	end

	test "overrides existing static files", %{conn: conn} do
	name = "pelmora"
	ref = "uguu"

	clear_config([:frontends, :primary], %{"name" => name, "ref" => ref})
	path = "#{@dir}/frontends/#{name}/#{ref}"

	File.mkdir_p!(path)
	File.write!("#{path}/index.html", "from frontend plug")

	index = get(conn, "/")
	assert html_response(index, 200) == "from frontend plug"
	end

	test "overrides existing static files for the `pleroma/admin` path", %{conn: conn} do
	name = "pelmora"
	ref = "uguu"

	clear_config([:frontends, :admin], %{"name" => name, "ref" => ref})
	path = "#{@dir}/frontends/#{name}/#{ref}"

	File.mkdir_p!(path)
	File.write!("#{path}/index.html", "from frontend plug")

	index = get(conn, "/pleroma/admin/")
	assert html_response(index, 200) == "from frontend plug"
	end

	test "exclude invalid path", %{conn: conn} do
	name = "pleroma-fe"
	ref = "dist"
	clear_config([:media_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")
	clear_config([:frontends, :primary], %{"name" => name, "ref" => ref})
	path = "#{@dir}/frontends/#{name}/#{ref}"

	File.mkdir_p!("#{path}/proxy/rr/ss")
	File.write!("#{path}/proxy/rr/ss/Ek7w8WPVcAApOvN.jpg:large", "FB image")

	url =
	Pleroma.Web.MediaProxy.encode_url("https://pbs.twimg.com/media/Ek7w8WPVcAApOvN.jpg:large")

	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Plug.Conn{status: :success} end do
	assert %Plug.Conn{status: :success} = get(conn, url)
	end
	end

	test "api routes are detected correctly" do
	# If this test fails we have probably added something
	# new that should be in /api/ instead
	expected_routes = [
	"api",
	"main",
	"ostatus_subscribe",
	"oauth",
	"akkoma",
	"objects",
	"activities",
	"notice",
	"@:nickname",
	":nickname",
	"users",
	"tags",
	"mailer",
	"inbox",
	"relay",
	"internal",
	".well-known",
	"nodeinfo",
	"manifest.json",
	"web",
	"auth",
	"embed",
	"proxy",
	"phoenix",
	"test",
	"user_exists",
	"check_password"
	]

	assert expected_routes == Pleroma.Web.Router.get_api_routes()
	end
	end
	diff --git a/test/pleroma/web/plugs/http_signature_plug_test.exs b/test/pleroma/web/plugs/http_signature_plug_test.exs
	index 34d0dc00e..a90c6533e 100644
	--- a/test/pleroma/web/plugs/http_signature_plug_test.exs
	+++ b/test/pleroma/web/plugs/http_signature_plug_test.exs
	@@ -1,143 +1,144 @@
	# 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.HTTPSignaturePlugTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	import Pleroma.Factory
	alias Pleroma.Web.Plugs.HTTPSignaturePlug
	alias Pleroma.Instances.Instance
	alias Pleroma.Repo

	import Plug.Conn
	import Phoenix.Controller, only: [put_format: 2]
	import Mock

	setup_with_mocks([
	{HTTPSignatures, [],
	[
	signature_for_conn: fn _ ->
	%{"keyId" => "http://mastodon.example.org/users/admin#main-key"}
	end,
	validate_conn: fn conn ->
	Map.get(conn.assigns, :valid_signature, true)
	end
	]}
	]) do
	:ok
	end

	defp submit_to_plug(host), do: submit_to_plug(host, :get, "/doesntmattter")

	defp submit_to_plug(host, method, path) do
	params = %{"actor" => "http://#{host}/users/admin"}

	build_conn(method, path, params)
	\|> put_req_header(
	"signature",
	"keyId=\"http://#{host}/users/admin#main-key"
	)
	\|> put_format("activity+json")
	\|> HTTPSignaturePlug.call(%{})
	end

	test "it call HTTPSignatures to check validity if the actor signed it" do
	params = %{"actor" => "http://mastodon.example.org/users/admin"}
	conn = build_conn(:get, "/doesntmattter", params)

	conn =
	conn
	\|> put_req_header(
	"signature",
	"keyId=\"http://mastodon.example.org/users/admin#main-key"
	)
	\|> put_format("activity+json")
	\|> HTTPSignaturePlug.call(%{})

	assert conn.assigns.valid_signature == true
	assert conn.assigns.signature_actor_id == params["actor"]
	assert conn.halted == false
	assert called(HTTPSignatures.validate_conn(:_))
	end

	test "it sets request signatures property on the instance" do
	host = "mastodon.example.org"
	conn = submit_to_plug(host)
	assert conn.assigns.valid_signature == true
	instance = Repo.get_by(Instance, %{host: host})
	assert instance.has_request_signatures
	end

	test "it does not set request signatures property on the instance when using inbox" do
	host = "mastodon.example.org"
	conn = submit_to_plug(host, :post, "/inbox")
	assert conn.assigns.valid_signature == true

	# we don't even create the instance entry if its just POST /inbox
	refute Repo.get_by(Instance, %{host: host})
	end

	test "it does not set request signatures property on the instance when its cached" do
	host = "mastodon.example.org"
	Cachex.put(:request_signatures_cache, host, true)
	conn = submit_to_plug(host)
	assert conn.assigns.valid_signature == true

	# we don't even create the instance entry if it was already done
	refute Repo.get_by(Instance, %{host: host})
	end

	describe "requires a signature when `authorized_fetch_mode` is enabled" do
	setup do
	clear_config([:activitypub, :authorized_fetch_mode], true)

	params = %{"actor" => "http://mastodon.example.org/users/admin"}
	conn = build_conn(:get, "/doesntmattter", params) \|> put_format("activity+json")

	[conn: conn]
	end

	test "and signature is present and incorrect", %{conn: conn} do
	conn =
	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header(
	"signature",
	"keyId=\"http://mastodon.example.org/users/admin#main-key"
	)
	\|> HTTPSignaturePlug.call(%{})

	assert conn.assigns.valid_signature == false
	assert called(HTTPSignatures.validate_conn(:_))
	end

	test "and signature is correct", %{conn: conn} do
	conn =
	conn
	\|> put_req_header(
	"signature",
	"keyId=\"http://mastodon.example.org/users/admin#main-key"
	)
	\|> HTTPSignaturePlug.call(%{})

	assert conn.assigns.valid_signature == true
	assert called(HTTPSignatures.validate_conn(:_))
	end

	test "and halts the connection when `signature` header is not present", %{conn: conn} do
	conn = HTTPSignaturePlug.call(conn, %{})
	assert conn.assigns[:valid_signature] == nil
	end
	end

	test "aliases redirected /object endpoints", _ do
	obj = insert(:note)
	act = insert(:note_activity, note: obj)
	params = %{"actor" => "someparam"}
	path = URI.parse(obj.data["id"]).path
	conn = build_conn(:get, path, params)

	assert ["/notice/#{act.id}", "/notice/#{act.id}?actor=someparam"] ==
	HTTPSignaturePlug.route_aliases(conn)
	end
	end
	diff --git a/test/pleroma/web/plugs/o_auth_scopes_plug_test.exs b/test/pleroma/web/plugs/o_auth_scopes_plug_test.exs
	index 0385a5efc..b2af966b9 100644
	--- a/test/pleroma/web/plugs/o_auth_scopes_plug_test.exs
	+++ b/test/pleroma/web/plugs/o_auth_scopes_plug_test.exs
	@@ -1,172 +1,173 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.OAuthScopesPlugTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	alias Pleroma.Repo
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	import Mock
	import Pleroma.Factory

	test "is not performed if marked as skipped", %{conn: conn} do
	with_mock OAuthScopesPlug, [:passthrough], perform: &passthrough([&1, &2]) do
	conn =
	conn
	\|> OAuthScopesPlug.skip_plug()
	\|> OAuthScopesPlug.call(%{scopes: ["random_scope"]})

	refute called(OAuthScopesPlug.perform(:_, :_))
	refute conn.halted
	end
	end

	test "if `token.scopes` fulfills specified 'any of' conditions, " <>
	"proceeds with no op",
	%{conn: conn} do
	token = insert(:oauth_token, scopes: ["read", "write"]) \|> Repo.preload(:user)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{scopes: ["read"]})

	refute conn.halted
	assert conn.assigns[:user]
	end

	test "if `token.scopes` fulfills specified 'all of' conditions, " <>
	"proceeds with no op",
	%{conn: conn} do
	token = insert(:oauth_token, scopes: ["scope1", "scope2", "scope3"]) \|> Repo.preload(:user)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{scopes: ["scope2", "scope3"], op: :&})

	refute conn.halted
	assert conn.assigns[:user]
	end

	describe "with `fallback: :proceed_unauthenticated` option, " do
	test "if `token.scopes` doesn't fulfill specified conditions, " <>
	"clears :user and :token assigns",
	%{conn: conn} do
	user = insert(:user)
	token1 = insert(:oauth_token, scopes: ["read", "write"], user: user)

	for token <- [token1, nil], op <- [:\|, :&] do
	ret_conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{
	scopes: ["follow"],
	op: op,
	fallback: :proceed_unauthenticated
	})

	refute ret_conn.halted
	refute ret_conn.assigns[:user]
	refute ret_conn.assigns[:token]
	end
	end
	end

	describe "without :fallback option, " do
	test "if `token.scopes` does not fulfill specified 'any of' conditions, " <>
	"returns 403 and halts",
	%{conn: conn} do
	for token <- [insert(:oauth_token, scopes: ["read", "write"]), nil] do
	any_of_scopes = ["follow", "push"]

	ret_conn =
	conn
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{scopes: any_of_scopes})

	assert ret_conn.halted
	assert 403 == ret_conn.status

	expected_error = "Insufficient permissions: #{Enum.join(any_of_scopes, " \| ")}."
	assert Jason.encode!(%{error: expected_error}) == ret_conn.resp_body
	end
	end

	test "if `token.scopes` does not fulfill specified 'all of' conditions, " <>
	"returns 403 and halts",
	%{conn: conn} do
	for token <- [insert(:oauth_token, scopes: ["read", "write"]), nil] do
	token_scopes = (token && token.scopes) \|\| []
	all_of_scopes = ["write", "follow"]

	conn =
	conn
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{scopes: all_of_scopes, op: :&})

	assert conn.halted
	assert 403 == conn.status

	expected_error =
	"Insufficient permissions: #{Enum.join(all_of_scopes -- token_scopes, " & ")}."

	assert Jason.encode!(%{error: expected_error}) == conn.resp_body
	end
	end
	end

	describe "with hierarchical scopes, " do
	test "if `token.scopes` fulfills specified 'any of' conditions, " <>
	"proceeds with no op",
	%{conn: conn} do
	token = insert(:oauth_token, scopes: ["read", "write"]) \|> Repo.preload(:user)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{scopes: ["read:something"]})

	refute conn.halted
	assert conn.assigns[:user]
	end

	test "if `token.scopes` fulfills specified 'all of' conditions, " <>
	"proceeds with no op",
	%{conn: conn} do
	token = insert(:oauth_token, scopes: ["scope1", "scope2", "scope3"]) \|> Repo.preload(:user)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> OAuthScopesPlug.call(%{scopes: ["scope1:subscope", "scope2:subscope"], op: :&})

	refute conn.halted
	assert conn.assigns[:user]
	end
	end

	describe "filter_descendants/2" do
	test "filters scopes which directly match or are ancestors of supported scopes" do
	f = fn scopes, supported_scopes ->
	OAuthScopesPlug.filter_descendants(scopes, supported_scopes)
	end

	assert f.(["read", "follow"], ["write", "read"]) == ["read"]

	assert f.(["read", "write:something", "follow"], ["write", "read"]) ==
	["read", "write:something"]

	assert f.(["admin:read"], ["write", "read"]) == []

	assert f.(["admin:read"], ["write", "admin"]) == ["admin:read"]
	end
	end
	end
	diff --git a/test/pleroma/web/plugs/plug_helper_test.exs b/test/pleroma/web/plugs/plug_helper_test.exs
	index 962e6ce7b..26a9efcb0 100644
	--- a/test/pleroma/web/plugs/plug_helper_test.exs
	+++ b/test/pleroma/web/plugs/plug_helper_test.exs
	@@ -1,91 +1,92 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.PlugHelperTest do
	@moduledoc "Tests for the functionality added via `use Pleroma.Web, :plug`"

	alias Pleroma.Web.Plugs.ExpectAuthenticatedCheckPlug
	alias Pleroma.Web.Plugs.ExpectPublicOrAuthenticatedCheckPlug
	alias Pleroma.Web.Plugs.PlugHelper

	import Mock

	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked

	describe "when plug is skipped, " do
	setup_with_mocks(
	[
	{ExpectPublicOrAuthenticatedCheckPlug, [:passthrough], []}
	],
	%{conn: conn}
	) do
	conn = ExpectPublicOrAuthenticatedCheckPlug.skip_plug(conn)
	%{conn: conn}
	end

	test "it neither adds plug to called plugs list nor calls `perform/2`, " <>
	"regardless of :if_func / :unless_func options",
	%{conn: conn} do
	for opts <- [%{}, %{if_func: fn _ -> true end}, %{unless_func: fn _ -> false end}] do
	ret_conn = ExpectPublicOrAuthenticatedCheckPlug.call(conn, opts)

	refute called(ExpectPublicOrAuthenticatedCheckPlug.perform(:_, :_))
	refute PlugHelper.plug_called?(ret_conn, ExpectPublicOrAuthenticatedCheckPlug)
	end
	end
	end

	describe "when plug is NOT skipped, " do
	setup_with_mocks([{ExpectAuthenticatedCheckPlug, [:passthrough], []}]) do
	:ok
	end

	test "with no pre-run checks, adds plug to called plugs list and calls `perform/2`", %{
	conn: conn
	} do
	ret_conn = ExpectAuthenticatedCheckPlug.call(conn, %{})

	assert called(ExpectAuthenticatedCheckPlug.perform(ret_conn, :_))
	assert PlugHelper.plug_called?(ret_conn, ExpectAuthenticatedCheckPlug)
	end

	test "when :if_func option is given, calls the plug only if provided function evals tru-ish",
	%{conn: conn} do
	ret_conn = ExpectAuthenticatedCheckPlug.call(conn, %{if_func: fn _ -> false end})

	refute called(ExpectAuthenticatedCheckPlug.perform(:_, :_))
	refute PlugHelper.plug_called?(ret_conn, ExpectAuthenticatedCheckPlug)

	ret_conn = ExpectAuthenticatedCheckPlug.call(conn, %{if_func: fn _ -> true end})

	assert called(ExpectAuthenticatedCheckPlug.perform(ret_conn, :_))
	assert PlugHelper.plug_called?(ret_conn, ExpectAuthenticatedCheckPlug)
	end

	test "if :unless_func option is given, calls the plug only if provided function evals falsy",
	%{conn: conn} do
	ret_conn = ExpectAuthenticatedCheckPlug.call(conn, %{unless_func: fn _ -> true end})

	refute called(ExpectAuthenticatedCheckPlug.perform(:_, :_))
	refute PlugHelper.plug_called?(ret_conn, ExpectAuthenticatedCheckPlug)

	ret_conn = ExpectAuthenticatedCheckPlug.call(conn, %{unless_func: fn _ -> false end})

	assert called(ExpectAuthenticatedCheckPlug.perform(ret_conn, :_))
	assert PlugHelper.plug_called?(ret_conn, ExpectAuthenticatedCheckPlug)
	end

	test "allows a plug to be called multiple times (even if it's in called plugs list)", %{
	conn: conn
	} do
	conn = ExpectAuthenticatedCheckPlug.call(conn, %{an_option: :value1})
	assert called(ExpectAuthenticatedCheckPlug.perform(conn, %{an_option: :value1}))

	assert PlugHelper.plug_called?(conn, ExpectAuthenticatedCheckPlug)

	conn = ExpectAuthenticatedCheckPlug.call(conn, %{an_option: :value2})
	assert called(ExpectAuthenticatedCheckPlug.perform(conn, %{an_option: :value2}))
	end
	end
	end
	diff --git a/test/pleroma/web/static_fe/static_fe_controller_test.exs b/test/pleroma/web/static_fe/static_fe_controller_test.exs
	index a66504ac8..935e44171 100644
	--- a/test/pleroma/web/static_fe/static_fe_controller_test.exs
	+++ b/test/pleroma/web/static_fe/static_fe_controller_test.exs
	@@ -1,293 +1,294 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
	use Pleroma.Web.ConnCase, async: false

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup_all do: clear_config([:static_fe, :enabled], true)
	+ setup do: clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	user = insert(:user)

	%{conn: conn, user: user}
	end

	describe "user profile html" do
	test "just the profile as HTML", %{conn: conn, user: user} do
	conn = get(conn, "/users/#{user.nickname}")

	assert html_response(conn, 200) =~ user.nickname
	end

	test "404 when user not found", %{conn: conn} do
	conn = get(conn, "/users/limpopo")

	assert html_response(conn, 404) =~ "not found"
	end

	test "profile does not include private messages", %{conn: conn, user: user} do
	CommonAPI.post(user, %{status: "public"})
	CommonAPI.post(user, %{status: "private", visibility: "private"})

	conn = get(conn, "/users/#{user.nickname}")

	html = html_response(conn, 200)

	assert html =~ "\npublic\n"
	refute html =~ "\nprivate\n"
	end

	test "main page does not include replies", %{conn: conn, user: user} do
	{:ok, op} = CommonAPI.post(user, %{status: "beep"})
	CommonAPI.post(user, %{status: "boop", in_reply_to_id: op})

	conn = get(conn, "/users/#{user.nickname}")

	html = html_response(conn, 200)

	assert html =~ "\nbeep\n"
	refute html =~ "\nboop\n"
	end

	test "media page only includes posts with attachments", %{conn: conn, user: user} do
	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)

	CommonAPI.post(user, %{status: "virgin text post"})
	CommonAPI.post(user, %{status: "chad post with attachment", media_ids: [media_id]})

	conn = get(conn, "/users/#{user.nickname}/media")

	html = html_response(conn, 200)

	assert html =~ "\nchad post with attachment\n"
	refute html =~ "\nvirgin text post\n"
	end

	test "show follower list", %{conn: conn, user: user} do
	follower = insert(:user)
	CommonAPI.follow(follower, user)

	conn = get(conn, "/users/#{user.nickname}/followers")

	html = html_response(conn, 200)

	assert html =~ "user-card"
	end

	test "don't show followers if hidden", %{conn: conn, user: user} do
	follower = insert(:user)
	CommonAPI.follow(follower, user)

	{:ok, user} =
	user
	\|> User.update_changeset(%{hide_followers: true})
	\|> User.update_and_set_cache()

	conn = get(conn, "/users/#{user.nickname}/followers")

	html = html_response(conn, 200)

	refute html =~ "user-card"
	end

	test "pagination", %{conn: conn, user: user} do
	Enum.map(1..30, fn i -> CommonAPI.post(user, %{status: "test#{i}"}) end)

	conn = get(conn, "/users/#{user.nickname}")

	html = html_response(conn, 200)

	assert html =~ "\ntest30\n"
	assert html =~ "\ntest11\n"
	refute html =~ "\ntest10\n"
	refute html =~ "\ntest1\n"
	end

	test "pagination, page 2", %{conn: conn, user: user} do
	activities = Enum.map(1..30, fn i -> CommonAPI.post(user, %{status: "test#{i}"}) end)
	{:ok, a11} = Enum.at(activities, 11)

	conn = get(conn, "/users/#{user.nickname}?max_id=#{a11.id}")

	html = html_response(conn, 200)

	assert html =~ "\ntest1\n"
	assert html =~ "\ntest10\n"
	refute html =~ "\ntest20\n"
	refute html =~ "\ntest29\n"
	end

	test "does not require authentication on non-federating instances", %{
	conn: conn,
	user: user
	} do
	clear_config([:instance, :federating], false)

	conn = get(conn, "/users/#{user.nickname}")

	assert html_response(conn, 200) =~ user.nickname
	end

	test "returns 404 for local user with `restrict_unauthenticated/profiles/local` setting", %{
	conn: conn
	} do
	clear_config([:restrict_unauthenticated, :profiles, :local], true)

	local_user = insert(:user, local: true)

	conn
	\|> get("/users/#{local_user.nickname}")
	\|> html_response(404)
	end
	end

	describe "notice html" do
	test "single notice page", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})

	conn = get(conn, "/notice/#{activity.id}")

	html = html_response(conn, 200)
	assert html =~ "<div class=\"panel conversation\">"
	assert html =~ user.nickname
	assert html =~ "testing a thing!"
	end

	test "redirects to json if requested", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})

	conn =
	conn
	\|> put_req_header(
	"accept",
	"Accept: application/activity+json, application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\", text/html"
	)
	\|> get("/notice/#{activity.id}")

	assert redirected_to(conn, 302) =~ activity.data["object"]
	end

	test "filters HTML tags", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "<script>alert('xss')</script>"})

	conn =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{activity.id}")

	html = html_response(conn, 200)
	assert html =~ ~s[<script>alert('xss')</script>]
	end

	test "shows the whole thread", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "space: the final frontier"})

	CommonAPI.post(user, %{
	status: "these are the voyages or something",
	in_reply_to_status_id: activity.id
	})

	conn = get(conn, "/notice/#{activity.id}")

	html = html_response(conn, 200)
	assert html =~ "the final frontier"
	assert html =~ "voyages"
	end

	test "redirect by AP object ID", %{conn: conn, user: user} do
	{:ok, %Activity{data: %{"object" => object_url}}} =
	CommonAPI.post(user, %{status: "beam me up"})

	conn = get(conn, URI.parse(object_url).path)

	assert html_response(conn, 302) =~ "redirected"
	end

	test "redirect by activity ID", %{conn: conn, user: user} do
	{:ok, %Activity{data: %{"id" => id}}} =
	CommonAPI.post(user, %{status: "I'm a doctor, not a devops!"})

	conn = get(conn, URI.parse(id).path)

	assert html_response(conn, 302) =~ "redirected"
	end

	test "404 when notice not found", %{conn: conn} do
	conn = get(conn, "/notice/88c9c317")

	assert html_response(conn, 404) =~ "not found"
	end

	test "404 for private status", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "don't show me!", visibility: "private"})

	conn = get(conn, "/notice/#{activity.id}")

	assert html_response(conn, 404) =~ "not found"
	end

	test "302 for remote cached status", %{conn: conn, user: user} do
	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => user.ap_id,
	"object" => %{
	"to" => user.follower_address,
	"cc" => "https://www.w3.org/ns/activitystreams#Public",
	"id" => Utils.generate_object_id(),
	"content" => "blah blah blah",
	"type" => "Note",
	"attributedTo" => user.ap_id
	}
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	conn = get(conn, "/notice/#{activity.id}")

	assert html_response(conn, 302) =~ "redirected"
	end

	test "does not require authentication on non-federating instances", %{
	conn: conn,
	user: user
	} do
	clear_config([:instance, :federating], false)

	{:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})

	conn = get(conn, "/notice/#{activity.id}")

	assert html_response(conn, 200) =~ "testing a thing!"
	end

	test "returns 404 for local public activity with `restrict_unauthenticated/activities/local` setting",
	%{conn: conn, user: user} do
	clear_config([:restrict_unauthenticated, :activities, :local], true)

	{:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})

	conn
	\|> get("/notice/#{activity.id}")
	\|> html_response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/twitter_api/util_controller_test.exs b/test/pleroma/web/twitter_api/util_controller_test.exs
	index 53a347d42..169e9981c 100644
	--- a/test/pleroma/web/twitter_api/util_controller_test.exs
	+++ b/test/pleroma/web/twitter_api/util_controller_test.exs
	@@ -1,987 +1,988 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
	use Pleroma.Web.ConnCase, async: false
	+ @moduletag :mocked
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User

	import Pleroma.Factory
	import Mock

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

	setup do: clear_config([:instance])
	setup do: clear_config([:frontend_configurations, :pleroma_fe])

	describe "PUT /api/pleroma/notification_settings" do
	setup do: oauth_access(["write:accounts"])

	test "it updates notification settings", %{user: user, conn: conn} do
	conn
	\|> put(
	"/api/pleroma/notification_settings?#{URI.encode_query(%{block_from_strangers: true})}"
	)
	\|> json_response_and_validate_schema(:ok)

	user = refresh_record(user)

	assert %Pleroma.User.NotificationSetting{
	block_from_strangers: true,
	hide_notification_contents: false
	} == user.notification_settings
	end

	test "it updates notification settings to enable hiding contents", %{user: user, conn: conn} do
	conn
	\|> put(
	"/api/pleroma/notification_settings?#{URI.encode_query(%{hide_notification_contents: 1})}"
	)
	\|> json_response_and_validate_schema(:ok)

	user = refresh_record(user)

	assert %Pleroma.User.NotificationSetting{
	block_from_strangers: false,
	hide_notification_contents: true
	} == user.notification_settings
	end
	end

	describe "GET /api/pleroma/frontend_configurations" do
	test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
	config = [
	frontend_a: %{
	x: 1,
	y: 2
	},
	frontend_b: %{
	z: 3
	}
	]

	clear_config(:frontend_configurations, config)

	response =
	conn
	\|> get("/api/pleroma/frontend_configurations")
	\|> json_response_and_validate_schema(:ok)

	assert response == Jason.encode!(config \|> Enum.into(%{})) \|> Jason.decode!()
	end
	end

	describe "/api/v1/pleroma/emoji" do
	test "returns json with custom emoji with tags", %{conn: conn} do
	emoji =
	conn
	\|> get("/api/v1/pleroma/emoji")
	\|> json_response_and_validate_schema(200)

	assert Enum.all?(emoji, fn
	{_key,
	%{
	"image_url" => url,
	"tags" => tags
	}} ->
	is_binary(url) and is_list(tags)
	end)
	end
	end

	describe "GET /api/v1/pleroma/healthcheck" do
	setup do: clear_config([:instance, :healthcheck])

	test "returns 503 when healthcheck disabled", %{conn: conn} do
	clear_config([:instance, :healthcheck], false)

	response =
	conn
	\|> get("/api/v1/pleroma/healthcheck")
	\|> json_response_and_validate_schema(503)

	assert response == %{}
	end

	test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
	clear_config([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
	response =
	conn
	\|> get("/api/v1/pleroma/healthcheck")
	\|> json_response_and_validate_schema(200)

	assert %{
	"active" => _,
	"healthy" => true,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end

	test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
	clear_config([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
	response =
	conn
	\|> get("/api/v1/pleroma/healthcheck")
	\|> json_response_and_validate_schema(503)

	assert %{
	"active" => _,
	"healthy" => false,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end
	end

	describe "POST /api/pleroma/disable_account" do
	setup do: oauth_access(["write:accounts"])

	test "with valid permissions and password, it disables the account", %{conn: conn, user: user} do
	response =
	conn
	\|> post("/api/pleroma/disable_account?password=test")
	\|> json_response_and_validate_schema(:ok)

	assert response == %{"status" => "success"}
	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	refute user.is_active
	end

	test "with valid permissions and invalid password, it returns an error", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/api/pleroma/disable_account?password=test1")
	\|> json_response_and_validate_schema(:ok)

	assert response == %{"error" => "Invalid password."}
	user = User.get_cached_by_id(user.id)

	assert user.is_active
	end
	end

	describe "POST /main/ostatus - remote_subscribe/2" do
	setup do: clear_config([:instance, :federating], true)

	test "renders subscribe form", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
	\|> response(:ok)

	refute response =~ "Could not find user"
	assert response =~ "Remotely follow #{user.nickname}"
	end

	test "renders subscribe form with error when user not found", %{conn: conn} do
	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
	\|> response(:ok)

	assert response =~ "Could not find user"
	refute response =~ "Remotely follow"
	end

	test "it redirect to webfinger url", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	conn =
	conn
	\|> post("/main/ostatus", %{
	"user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
	})

	assert redirected_to(conn) ==
	"https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
	end

	test "it renders form with error when user not found", %{conn: conn} do
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	response =
	conn
	\|> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
	\|> response(:ok)

	assert response =~ "Something went wrong."
	end
	end

	describe "POST /main/ostatus - remote_subscribe/2 - with statuses" do
	setup do: clear_config([:instance, :federating], true)

	test "renders subscribe form", %{conn: conn} do
	user = insert(:user)
	status = insert(:note_activity, %{user: user})
	status_id = status.id

	assert is_binary(status_id)

	response =
	conn
	\|> post("/main/ostatus", %{"status_id" => status_id, "profile" => ""})
	\|> response(:ok)

	refute response =~ "Could not find status"
	assert response =~ "Interacting with"
	end

	test "renders subscribe form with error when status not found", %{conn: conn} do
	response =
	conn
	\|> post("/main/ostatus", %{"status_id" => "somerandomid", "profile" => ""})
	\|> response(:ok)

	assert response =~ "Could not find status"
	refute response =~ "Interacting with"
	end

	test "it redirect to webfinger url", %{conn: conn} do
	user = insert(:user)
	status = insert(:note_activity, %{user: user})
	status_id = status.id
	status_ap_id = status.data["object"]

	assert is_binary(status_id)
	assert is_binary(status_ap_id)

	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	conn =
	conn
	\|> post("/main/ostatus", %{
	"status" => %{"status_id" => status_id, "profile" => user2.ap_id}
	})

	assert redirected_to(conn) ==
	"https://social.heldscal.la/main/ostatussub?profile=#{status_ap_id}"
	end

	test "it renders form with error when status not found", %{conn: conn} do
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	response =
	conn
	\|> post("/main/ostatus", %{
	"status" => %{"status_id" => "somerandomid", "profile" => user2.ap_id}
	})
	\|> response(:ok)

	assert response =~ "Something went wrong."
	end
	end

	describe "GET /main/ostatus - show_subscribe_form/2" do
	setup do: clear_config([:instance, :federating], true)

	test "it works with users", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> get("/main/ostatus", %{"nickname" => user.nickname})
	\|> response(:ok)

	refute response =~ "Could not find user"
	assert response =~ "Remotely follow #{user.nickname}"
	end

	test "it works with statuses", %{conn: conn} do
	user = insert(:user)
	status = insert(:note_activity, %{user: user})
	status_id = status.id

	assert is_binary(status_id)

	response =
	conn
	\|> get("/main/ostatus", %{"status_id" => status_id})
	\|> response(:ok)

	refute response =~ "Could not find status"
	assert response =~ "Interacting with"
	end
	end

	test "it returns new captcha", %{conn: conn} do
	with_mock Pleroma.Captcha,
	new: fn -> "test_captcha" end do
	resp =
	conn
	\|> get("/api/v1/pleroma/captcha")
	\|> response(200)

	assert resp == "\"test_captcha\""
	assert called(Pleroma.Captcha.new())
	end
	end

	describe "POST /api/pleroma/change_email" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and invalid email", %{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "test", email: "foobar"})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "Email has invalid format."
	}
	end

	test "with proper permissions, valid password and no email", %{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "test"})

	assert %{"error" => "Missing field: email."} = json_response_and_validate_schema(conn, 400)
	end

	test "with proper permissions, valid password and blank email, when instance requires user email",
	%{
	conn: conn
	} 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)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "test", email: ""})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Email can't be blank."}
	end

	test "with proper permissions, valid password and blank email, when instance does not require user email",
	%{
	conn: conn
	} 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)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "test", email: ""})

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	end

	test "with proper permissions, valid password and non unique email", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{password: "test", email: user.email})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "Email has already been taken."
	}
	end

	test "with proper permissions, valid password and valid email", %{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_email", %{
	password: "test",
	email: "cofe@foobar.com"
	})

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	end
	end

	describe "POST /api/pleroma/change_password" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and new password and confirmation not matching",
	%{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with proper permissions, valid password and invalid new password", %{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	password: "test",
	new_password: "",
	new_password_confirmation: ""
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with proper permissions, valid password and matching new password and confirmation", %{
	conn: conn,
	user: user
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/change_password",
	%{
	password: "test",
	new_password: "newpass",
	new_password_confirmation: "newpass"
	}
	)

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	fetched_user = User.get_cached_by_id(user.id)
	assert Pleroma.Password.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> post("/api/pleroma/delete_account")

	assert json_response_and_validate_schema(conn, 403) ==
	%{"error" => "Insufficient permissions: write:accounts."}
	end

	test "with proper permissions and wrong or missing password", %{conn: conn} do
	for params <- [%{"password" => "hi"}, %{}] do
	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/delete_account", params)

	assert json_response_and_validate_schema(ret_conn, 200) == %{
	"error" => "Invalid password."
	}
	end
	end

	test "with proper permissions and valid password (URL query)", %{conn: conn, user: user} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/delete_account?password=test")

	ObanHelpers.perform_all()
	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}

	user = User.get_by_id(user.id)
	refute user.is_active
	assert user.name == nil
	assert user.bio == ""
	assert user.password_hash == nil
	end

	test "with proper permissions and valid password (JSON body)", %{conn: conn, user: user} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/delete_account", %{password: "test"})

	ObanHelpers.perform_all()
	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}

	user = User.get_by_id(user.id)
	refute user.is_active
	assert user.name == nil
	assert user.bio == ""
	assert user.password_hash == nil
	end
	end

	describe "POST /api/pleroma/move_account" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	target_user = insert(:user)
	target_nick = target_user \|> User.full_nickname()

	conn =
	conn
	\|> assign(:token, nil)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "hi",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	target_user = insert(:user)
	target_nick = target_user \|> User.full_nickname()

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "hi",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and target account does not alias this",
	%{
	conn: conn
	} do
	target_user = insert(:user)
	target_nick = target_user \|> User.full_nickname()

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "test",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "Target account must have the origin in `alsoKnownAs`"
	}
	end

	test "with proper permissions, valid password and target account does not exist",
	%{
	conn: conn
	} do
	target_nick = "not_found@mastodon.social"

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "test",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 404) == %{
	"error" => "Target account not found."
	}
	end

	test "with proper permissions, valid password, remote target account aliases this and local cache does not exist",
	%{} do
	user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
	%{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)

	target_nick = "mewmew@lm.kazv.moe"

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "test",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	end

	test "with proper permissions, valid password, remote target account aliases this and local cache does not alias this",
	%{} do
	user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
	%{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)

	target_user =
	insert(
	:user,
	ap_id: "https://lm.kazv.moe/users/mewmew",
	nickname: "mewmew@lm.kazv.moe",
	local: false
	)

	target_nick = target_user \|> User.full_nickname()

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "test",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	end

	test "with proper permissions, valid password, remote target account does not alias this and local cache aliases this",
	%{
	user: user,
	conn: conn
	} do
	target_user =
	insert(
	:user,
	ap_id: "https://lm.kazv.moe/users/mewmew",
	nickname: "mewmew@lm.kazv.moe",
	local: false,
	also_known_as: [user.ap_id]
	)

	target_nick = target_user \|> User.full_nickname()

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/move_account", %{
	"password" => "test",
	"target_account" => target_nick
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "Target account must have the origin in `alsoKnownAs`"
	}
	end

	test "with proper permissions, valid password and target account aliases this", %{
	conn: conn,
	user: user
	} do
	target_user = insert(:user, also_known_as: [user.ap_id])
	target_nick = target_user \|> User.full_nickname()
	follower = insert(:user)

	User.follow(follower, user)

	assert User.following?(follower, user)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/move_account",
	%{
	password: "test",
	target_account: target_nick
	}
	)

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}

	params = %{
	"op" => "move_following",
	"origin_id" => user.id,
	"target_id" => target_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, user)
	assert User.following?(follower, target_user)
	end

	test "prefix nickname by @ should work", %{
	conn: conn,
	user: user
	} do
	target_user = insert(:user, also_known_as: [user.ap_id])
	target_nick = target_user \|> User.full_nickname()
	follower = insert(:user)

	User.follow(follower, user)

	assert User.following?(follower, user)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/move_account",
	%{
	password: "test",
	target_account: "@" <> target_nick
	}
	)

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}

	params = %{
	"op" => "move_following",
	"origin_id" => user.id,
	"target_id" => target_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, user)
	assert User.following?(follower, target_user)
	end
	end

	describe "GET /api/pleroma/aliases" do
	setup do: oauth_access(["read:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> get("/api/pleroma/aliases")

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: read:accounts."
	}
	end

	test "with permissions", %{
	conn: conn
	} do
	assert %{"aliases" => []} =
	conn
	\|> get("/api/pleroma/aliases")
	\|> json_response_and_validate_schema(200)
	end

	test "with permissions and aliases", %{} do
	user = insert(:user)
	user2 = insert(:user)

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

	%{user: _user, conn: conn} = oauth_access(["read:accounts"], user: user)

	assert %{"aliases" => aliases} =
	conn
	\|> get("/api/pleroma/aliases")
	\|> json_response_and_validate_schema(200)

	assert aliases == [user2 \|> User.full_nickname()]
	end
	end

	describe "PUT /api/pleroma/aliases" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/aliases", %{alias: "none"})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with permissions, no alias param", %{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/aliases", %{})

	assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
	end

	test "with permissions, with alias param", %{
	conn: conn
	} do
	user2 = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/aliases", %{alias: user2 \|> User.full_nickname()})

	assert json_response_and_validate_schema(conn, 200) == %{
	"status" => "success"
	}
	end
	end

	describe "DELETE /api/pleroma/aliases" do
	setup do
	alias_user = insert(:user)
	non_alias_user = insert(:user)
	user = insert(:user, also_known_as: [alias_user.ap_id])

	oauth_access(["write:accounts"], user: user)
	\|> Map.put(:alias_user, alias_user)
	\|> Map.put(:non_alias_user, non_alias_user)
	end

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/aliases", %{alias: "none"})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with permissions, no alias param", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/aliases", %{})

	assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
	end

	test "with permissions, account does not have such alias", %{
	conn: conn,
	non_alias_user: non_alias_user
	} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/aliases", %{
	alias: non_alias_user \|> User.full_nickname()
	})

	assert %{"error" => "Account has no such alias."} =
	json_response_and_validate_schema(conn, 404)
	end

	test "with permissions, account does have such alias", %{
	conn: conn,
	alias_user: alias_user
	} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/aliases", %{alias: alias_user \|> User.full_nickname()})

	assert %{"status" => "success"} = json_response_and_validate_schema(conn, 200)
	end
	end
	end
	diff --git a/test/pleroma/workers/receiver_worker_test.exs b/test/pleroma/workers/receiver_worker_test.exs
	index fbd2b82e7..e816d8db5 100644
	--- a/test/pleroma/workers/receiver_worker_test.exs
	+++ b/test/pleroma/workers/receiver_worker_test.exs
	@@ -1,25 +1,26 @@
	# 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
	+ @moduletag :mocked

	import Mock
	import Pleroma.Factory

	alias Pleroma.Workers.ReceiverWorker

	test "it ignores MRF reject" do
	params = insert(:note).data

	with_mock Pleroma.Web.ActivityPub.Transmogrifier,
	handle_incoming: fn _ -> {:reject, "MRF"} end do
	assert {:discard, "MRF"} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 9, 10:03 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1784678
Default Alt Text: (658 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions