No OneTemporary
Actions

Authored By

Unknown

Size

206 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/reduce-flaky-tests.skip b/changelog.d/reduce-flaky-tests.skip
	new file mode 100644
	index 000000000..0375762c0
	--- /dev/null
	+++ b/changelog.d/reduce-flaky-tests.skip
	@@ -0,0 +1 @@
	+Reduce the number of flaky tests by making them sync if they affect the global state, and silence noisy test output.
	diff --git a/config/test.exs b/config/test.exs
	index 4da2b4f57..9652b7d4b 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,214 +1,214 @@
	import Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	url: [port: 4001],
	server: true

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, :console,
	level: :warning,
	format: "\n[$level] $message\n"

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload,
	filters: [],
	link_name: false,
	default_description: :filename

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false,
	static_dir: "test/instance_static/"

	config :pleroma, :activitypub,
	sign_object_fetches: false,
	follow_handshake_timeout: 0,
	client_api_enabled: true

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	port: System.get_env("DB_PORT") \|\| "5432",
	pool: Ecto.Adapters.SQL.Sandbox,
	pool_size: System.schedulers_online() * 2,
	log: false

	config :pleroma, :dangerzone, override_repo_pool_size: true

	# Reduce hash rounds for testing
	config :pleroma, :password, iterations: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	max_body: 2_000_000

	config :pleroma, :instance,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	config :pleroma, Oban, testing: :manual

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit, %{}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	config :pleroma, :http, send_user_agent: false

	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	-IO.puts("RUM enabled: #{rum_enabled}")

	config :joken, default_signer: "yU8uHKq+yyAkZ11Hx//jcdacWc8yQ1bxAAGrplzB0Zwwjkp35v0RK9SO8WTPr6QZ"

	config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock

	config :pleroma, :modules, runtime_dir: "test/fixtures/modules"

	config :pleroma, Pleroma.Gun, Pleroma.GunMock

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: true

	config :pleroma, Pleroma.Web.Plugs.RemoteIp, enabled: false

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: true

	config :tzdata, :autoupdate, :disabled

	config :pleroma, :mrf, policies: []

	config :pleroma, :pipeline,
	object_validator: Pleroma.Web.ActivityPub.ObjectValidatorMock,
	mrf: Pleroma.Web.ActivityPub.MRFMock,
	activity_pub: Pleroma.Web.ActivityPub.ActivityPubMock,
	side_effects: Pleroma.Web.ActivityPub.SideEffectsMock,
	federator: Pleroma.Web.FederatorMock,
	config: Pleroma.ConfigMock

	config :pleroma, :cachex, provider: Pleroma.CachexMock

	config :pleroma, Pleroma.Web.WebFinger, update_nickname_on_user_fetch: false

	config :pleroma, :side_effects,
	ap_streamer: Pleroma.Web.ActivityPub.ActivityPubMock,
	logger: Pleroma.LoggerMock

	config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch

	config :pleroma, Pleroma.Search.Meilisearch, url: "http://127.0.0.1:7700/", private_key: nil

	# Reduce recompilation time
	# https://dashbit.co/blog/speeding-up-re-compilation-of-elixir-projects
	config :phoenix, :plug_init_mode, :runtime

	config :pleroma, :config_impl, Pleroma.UnstubbedConfigMock
	config :pleroma, :datetime_impl, Pleroma.DateTimeMock

	config :pleroma, Pleroma.PromEx, disabled: true

	# Mox definitions. Only read during compile time.
	config :pleroma, Pleroma.User.Backup, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Uploaders.S3, ex_aws_impl: Pleroma.Uploaders.S3.ExAwsMock
	config :pleroma, Pleroma.Uploaders.S3, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Upload, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Language.LanguageDetector, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.ScheduledActivity, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Web.RichMedia.Helpers, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Uploaders.IPFS, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Web.Plugs.HTTPSecurityPlug, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Web.Plugs.HTTPSignaturePlug, config_impl: Pleroma.StaticStubbedConfigMock

	config :pleroma, Pleroma.Upload.Filter.AnonymizeFilename,
	config_impl: Pleroma.StaticStubbedConfigMock

	config :pleroma, Pleroma.Upload.Filter.Mogrify, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Upload.Filter.Mogrify, mogrify_impl: Pleroma.MogrifyMock

	config :pleroma, Pleroma.Signature, http_signatures_impl: Pleroma.StubbedHTTPSignaturesMock
	config :pleroma, Pleroma.Web.ActivityPub.Publisher, signature_impl: Pleroma.SignatureMock

	config :pleroma, Pleroma.Web.ActivityPub.Publisher,
	transmogrifier_impl: Pleroma.Web.ActivityPub.TransmogrifierMock

	peer_module =
	if String.to_integer(System.otp_release()) >= 25 do
	:peer
	else
	:slave
	end

	config :pleroma, Pleroma.Cluster, peer_module: peer_module

	config :pleroma, Pleroma.Application,
	background_migrators: false,
	internal_fetch: false,
	load_custom_modules: false,
	max_restarts: 100,
	streamer_registry: false,
	test_http_pools: true

	-config :pleroma, Pleroma.Web.Streaming, sync_streaming: true
	+config :pleroma, Pleroma.Web.Streamer, sync_streaming: true

	config :pleroma, Pleroma.Uploaders.Uploader, timeout: 1_000

	config :pleroma, Pleroma.Emoji.Loader, test_emoji: true

	config :pleroma, Pleroma.Web.RichMedia.Backfill,
	stream_out: Pleroma.Web.ActivityPub.ActivityPubMock

	config :pleroma, Pleroma.Web.Plugs.HTTPSecurityPlug, enable: false

	config :pleroma, Pleroma.User.Backup, tempdir: "test/tmp"

	if File.exists?("./config/test.secret.exs") do
	import_config "test.secret.exs"
	-else
	- IO.puts(
	- "You may want to create test.secret.exs to declare custom database connection parameters."
	- )
	end
	+
	+# Avoid noisy shutdown logs from os_mon during tests.
	+config :os_mon,
	+ start_cpu_sup: false,
	+ start_memsup: false
	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	index 8b3b2f18b..834b4fe14 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,431 +1,437 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Config do
	use Mix.Task

	import Ecto.Query
	import Mix.Pleroma

	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	@shortdoc "Manages the location of the config"
	@moduledoc File.read!("docs/administration/CLI_tasks/config.md")

	def run(["migrate_to_db"]) do
	check_configdb(fn ->
	start_pleroma()
	migrate_to_db()
	end)
	end

	def run(["migrate_from_db" \| options]) do
	check_configdb(fn ->
	start_pleroma()

	{opts, _} =
	OptionParser.parse!(options,
	strict: [env: :string, delete: :boolean, path: :string],
	aliases: [d: :delete]
	)

	migrate_from_db(opts)
	end)
	end

	def run(["dump"]) do
	check_configdb(fn ->
	start_pleroma()

	header = config_header()

	settings =
	ConfigDB
	\|> Repo.all()
	\|> Enum.sort()

	unless settings == [] do
	shell_info("#{header}")

	Enum.each(settings, &dump(&1))
	else
	shell_error("No settings in ConfigDB.")
	end
	end)
	end

	def run(["dump", group, key]) do
	check_configdb(fn ->
	start_pleroma()

	group = maybe_atomize(group)
	key = maybe_atomize(key)

	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> dump()
	end)
	end

	def run(["dump", group]) do
	check_configdb(fn ->
	start_pleroma()

	group = maybe_atomize(group)

	dump_group(group)
	end)
	end

	def run(["groups"]) do
	check_configdb(fn ->
	start_pleroma()

	groups =
	ConfigDB
	\|> distinct([c], true)
	\|> select([c], c.group)
	\|> Repo.all()

	if length(groups) > 0 do
	shell_info("The following configuration groups are set in ConfigDB:\r\n")
	groups \|> Enum.each(fn x -> shell_info("- #{x}") end)
	shell_info("\r\n")
	end
	end)
	end

	def run(["reset", "--force"]) do
	check_configdb(fn ->
	start_pleroma()
	truncatedb()
	shell_info("The ConfigDB settings have been removed from the database.")
	end)
	end

	def run(["reset"]) do
	check_configdb(fn ->
	start_pleroma()

	shell_info("The following settings will be permanently removed:")

	ConfigDB
	\|> Repo.all()
	\|> Enum.sort()
	\|> Enum.each(&dump(&1))

	shell_error("\nTHIS CANNOT BE UNDONE!")

	if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	truncatedb()

	shell_info("The ConfigDB settings have been removed from the database.")
	else
	shell_error("No changes made.")
	end
	end)
	end

	def run(["delete", "--force", group, key]) do
	start_pleroma()

	group = maybe_atomize(group)
	key = maybe_atomize(key)

	with true <- key_exists?(group, key) do
	shell_info("The following settings will be removed from ConfigDB:\n")

	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> dump()

	delete_key(group, key)
	else
	_ ->
	shell_error("No settings in ConfigDB for #{inspect(group)}, #{inspect(key)}. Aborting.")
	end
	end

	def run(["delete", "--force", group]) do
	start_pleroma()

	group = maybe_atomize(group)

	with true <- group_exists?(group) do
	shell_info("The following settings will be removed from ConfigDB:\n")
	dump_group(group)
	delete_group(group)
	else
	_ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
	end
	end

	def run(["delete", group, key]) do
	start_pleroma()

	group = maybe_atomize(group)
	key = maybe_atomize(key)

	with true <- key_exists?(group, key) do
	shell_info("The following settings will be removed from ConfigDB:\n")

	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> dump()

	if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	delete_key(group, key)
	else
	shell_error("No changes made.")
	end
	else
	_ ->
	shell_error("No settings in ConfigDB for #{inspect(group)}, #{inspect(key)}. Aborting.")
	end
	end

	def run(["delete", group]) do
	start_pleroma()

	group = maybe_atomize(group)

	with true <- group_exists?(group) do
	shell_info("The following settings will be removed from ConfigDB:\n")
	dump_group(group)

	if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	delete_group(group)
	else
	shell_error("No changes made.")
	end
	else
	_ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
	end
	end

	# Removes any policies that are not a real module
	# as they will prevent the server from starting
	def run(["fix_mrf_policies"]) do
	check_configdb(fn ->
	start_pleroma()

	group = :pleroma
	key = :mrf

	%{value: value} =
	group
	\|> ConfigDB.get_by_group_and_key(key)

	policies =
	Keyword.get(value, :policies, [])
	\|> Enum.filter(&is_atom(&1))
	\|> Enum.filter(fn mrf ->
	case Code.ensure_compiled(mrf) do
	{:module, _} -> true
	{:error, _} -> false
	end
	end)

	value = Keyword.put(value, :policies, policies)

	ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	end

	@spec migrate_to_db(Path.t() \| nil) :: any()
	def migrate_to_db(file_path \\ nil) do
	with :ok <- Pleroma.Config.DeprecationWarnings.warn() do
	config_file =
	if file_path do
	file_path
	else
	if Pleroma.Config.get(:release) do
	Pleroma.Config.get(:config_path)
	else
	"config/#{Pleroma.Config.get(:env)}.secret.exs"
	end
	end

	do_migrate_to_db(config_file)
	else
	_ ->
	shell_error("Migration is not allowed until all deprecation warnings have been resolved.")
	end
	end

	defp do_migrate_to_db(config_file) do
	if File.exists?(config_file) do
	shell_info("Migrating settings from file: #{Path.expand(config_file)}")
	truncatedb()

	custom_config =
	config_file
	\|> read_file()
	\|> elem(0)

	custom_config
	\|> Keyword.keys()
	\|> Enum.each(&create(&1, custom_config))
	else
	shell_info("To migrate settings, you must define custom settings in #{config_file}.")
	end
	end

	defp create(group, settings) do
	group
	\|> Pleroma.Config.Loader.filter_group(settings)
	\|> Enum.each(fn {key, value} ->
	{:ok, _} = ConfigDB.update_or_create(%{group: group, key: key, value: value})

	shell_info("Settings for key #{key} migrated.")
	end)

	shell_info("Settings for group #{inspect(group)} migrated.")
	end

	defp migrate_from_db(opts) do
	env = opts[:env] \|\| Pleroma.Config.get(:env)

	filename = "#{env}.exported_from_db.secret.exs"

	config_path =
	cond do
	opts[:path] ->
	opts[:path]

	Pleroma.Config.get(:release) ->
	:config_path
	\|> Pleroma.Config.get()
	\|> Path.dirname()

	true ->
	"config"
	end
	\|> Path.join(filename)

	with {:ok, file} <- File.open(config_path, [:write, :utf8]) do
	write_config(file, config_path, opts)
	shell_info("Database configuration settings have been exported to #{config_path}")
	else
	_ ->
	shell_error("Impossible to save settings to this directory #{Path.dirname(config_path)}")
	tmp_config_path = Path.join(System.tmp_dir!(), filename)
	file = File.open!(tmp_config_path)

	shell_info(
	"Saving database configuration settings to #{tmp_config_path}. Copy it to the #{Path.dirname(config_path)} manually."
	)

	write_config(file, tmp_config_path, opts)
	end
	end

	defp write_config(file, path, opts) do
	IO.write(file, config_header())

	ConfigDB
	\|> Repo.all()
	\|> Enum.each(&write_and_delete(&1, file, opts[:delete]))

	:ok = File.close(file)
	- System.cmd("mix", ["format", path])
	+
	+ # Ensure `mix format` runs in the same env as the current task and doesn't
	+ # emit config-time stderr noise (e.g. dev secret warnings) into `mix test`.
	+ System.cmd("mix", ["format", path],
	+ env: [{"MIX_ENV", to_string(Mix.env())}],
	+ stderr_to_stdout: true
	+ )
	end

	defp config_header, do: "import Config\r\n\r\n"
	defp read_file(config_file), do: Config.Reader.read_imports!(config_file)

	defp write_and_delete(config, file, delete?) do
	config
	\|> write(file)
	\|> delete(delete?)
	end

	defp write(config, file) do
	value = inspect(config.value, limit: :infinity)

	IO.write(file, "config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")

	config
	end

	defp delete(config, true) do
	{:ok, _} = Repo.delete(config)

	shell_info(
	"config #{inspect(config.group)}, #{inspect(config.key)} was deleted from the ConfigDB."
	)
	end

	defp delete(_config, _), do: :ok

	defp dump(%ConfigDB{} = config) do
	value = inspect(config.value, limit: :infinity)

	shell_info("config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")
	end

	defp dump(_), do: :noop

	defp dump_group(group) when is_atom(group) do
	group
	\|> ConfigDB.get_all_by_group()
	\|> Enum.each(&dump/1)
	end

	defp group_exists?(group) do
	group
	\|> ConfigDB.get_all_by_group()
	\|> Enum.any?()
	end

	defp key_exists?(group, key) do
	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> is_nil
	\|> Kernel.!()
	end

	defp maybe_atomize(arg) when is_atom(arg), do: arg

	defp maybe_atomize(":" <> arg), do: maybe_atomize(arg)

	defp maybe_atomize(arg) when is_binary(arg) do
	if ConfigDB.module_name?(arg) do
	String.to_existing_atom("Elixir." <> arg)
	else
	String.to_atom(arg)
	end
	end

	defp check_configdb(callback) do
	with true <- Pleroma.Config.get([:configurable_from_database]) do
	callback.()
	else
	_ ->
	shell_error(
	"ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
	)
	end
	end

	defp delete_key(group, key) do
	check_configdb(fn ->
	ConfigDB.delete(%{group: group, key: key})
	end)
	end

	defp delete_group(group) do
	check_configdb(fn ->
	group
	\|> ConfigDB.get_all_by_group()
	\|> Enum.each(&ConfigDB.delete/1)
	end)
	end

	defp truncatedb do
	Ecto.Adapters.SQL.query!(Repo, "TRUNCATE config;")
	Ecto.Adapters.SQL.query!(Repo, "ALTER SEQUENCE config_id_seq RESTART;")
	end
	end
	diff --git a/lib/pleroma/upload/filter/exiftool/read_description.ex b/lib/pleroma/upload/filter/exiftool/read_description.ex
	index 8c1ed82f8..8283b8643 100644
	--- a/lib/pleroma/upload/filter/exiftool/read_description.ex
	+++ b/lib/pleroma/upload/filter/exiftool/read_description.ex
	@@ -1,50 +1,54 @@
	# 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.Exiftool.ReadDescription do
	@moduledoc """
	Gets a valid description from the related EXIF tags and provides them in the response if no description is provided yet.
	It will first check ImageDescription, when that doesn't probide a valid description, it will check iptc:Caption-Abstract.
	A valid description means the fields are filled in and not too long (see `:instance, :description_limit`).
	"""
	@behaviour Pleroma.Upload.Filter

	def filter(%Pleroma.Upload{description: description})
	when is_binary(description),
	do: {:ok, :noop}

	def filter(%Pleroma.Upload{tempfile: file} = upload),
	do: {:ok, :filtered, upload \|> Map.put(:description, read_description_from_exif_data(file))}

	def filter(_, _), do: {:ok, :noop}

	defp read_description_from_exif_data(file) do
	nil
	\|> read_when_empty(file, "-ImageDescription")
	\|> read_when_empty(file, "-iptc:Caption-Abstract")
	end

	defp read_when_empty(current_description, _, _) when is_binary(current_description),
	do: current_description

	defp read_when_empty(_, file, tag) do
	- try do
	- {tag_content, 0} =
	- System.cmd("exiftool", ["-b", "-s3", tag, file],
	- stderr_to_stdout: false,
	- parallelism: true
	- )
	-
	- tag_content = String.trim(tag_content)
	-
	- if tag_content != "" and
	- String.length(tag_content) <=
	- Pleroma.Config.get([:instance, :description_limit]),
	- do: tag_content,
	- else: nil
	- rescue
	- _ in ErlangError -> nil
	+ if File.exists?(file) do
	+ try do
	+ {tag_content, 0} =
	+ System.cmd("exiftool", ["-m", "-b", "-s3", tag, file],
	+ stderr_to_stdout: false,
	+ parallelism: true
	+ )
	+
	+ tag_content = String.trim(tag_content)
	+
	+ if tag_content != "" and
	+ String.length(tag_content) <=
	+ Pleroma.Config.get([:instance, :description_limit]),
	+ do: tag_content,
	+ else: nil
	+ rescue
	+ _ in ErlangError -> nil
	+ end
	+ else
	+ nil
	end
	end
	end
	diff --git a/lib/pleroma/upload/filter/exiftool/strip_location.ex b/lib/pleroma/upload/filter/exiftool/strip_location.ex
	index 1744a286d..23346d234 100644
	--- a/lib/pleroma/upload/filter/exiftool/strip_location.ex
	+++ b/lib/pleroma/upload/filter/exiftool/strip_location.ex
	@@ -1,32 +1,33 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.Exiftool.StripLocation do
	@moduledoc """
	Strips GPS related EXIF tags and overwrites the file in place.
	Also strips or replaces filesystem metadata e.g., timestamps.
	"""
	@behaviour Pleroma.Upload.Filter

	# Formats not compatible with exiftool at this time
	def filter(%Pleroma.Upload{content_type: "image/heic"}), do: {:ok, :noop}
	def filter(%Pleroma.Upload{content_type: "image/webp"}), do: {:ok, :noop}
	def filter(%Pleroma.Upload{content_type: "image/svg" <> _}), do: {:ok, :noop}

	def filter(%Pleroma.Upload{tempfile: file, content_type: "image" <> _}) do
	try do
	- case System.cmd("exiftool", ["-overwrite_original", "-gps:all=", "-png:all=", file],
	+ case System.cmd("exiftool", ["-m", "-overwrite_original", "-gps:all=", "-png:all=", file],
	+ stderr_to_stdout: true,
	parallelism: true
	) do
	{_response, 0} -> {:ok, :filtered}
	- {error, 1} -> {:error, error}
	+ {error, _} -> {:error, error}
	end
	rescue
	e in ErlangError ->
	{:error, "#{__MODULE__}: #{inspect(e)}"}
	end
	end

	def filter(_), do: {:ok, :noop}
	end
	diff --git a/lib/pleroma/web/streamer.ex b/lib/pleroma/web/streamer.ex
	index aba42ee78..120e94751 100644
	--- a/lib/pleroma/web/streamer.ex
	+++ b/lib/pleroma/web/streamer.ex
	@@ -1,442 +1,442 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Streamer do
	require Logger
	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Marker
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.StreamerView
	require Pleroma.Constants

	@registry Pleroma.Web.StreamerRegistry

	def registry, do: @registry

	@public_streams Pleroma.Constants.public_streams()
	@local_streams ["public:local", "public:local:media"]
	@user_streams ["user", "user:notification", "direct", "user:pleroma_chat"]

	@doc "Expands and authorizes a stream, and registers the process for streaming."
	@spec get_topic_and_add_socket(
	stream :: String.t(),
	User.t() \| nil,
	Token.t() \| nil,
	map() \| nil
	) ::
	{:ok, topic :: String.t()} \| {:error, :bad_topic} \| {:error, :unauthorized}
	def get_topic_and_add_socket(stream, user, oauth_token, params \\ %{}) do
	with {:ok, topic} <- get_topic(stream, user, oauth_token, params) do
	add_socket(topic, oauth_token)
	end
	end

	defp can_access_stream(user, oauth_token, kind) do
	with {_, true} <- {:restrict?, Config.restrict_unauthenticated_access?(:timelines, kind)},
	{_, %User{id: user_id}, %Token{user_id: user_id}} <- {:user, user, oauth_token},
	{_, true} <-
	{:scopes,
	OAuthScopesPlug.filter_descendants(["read:statuses"], oauth_token.scopes) != []} do
	true
	else
	{:restrict?, _} ->
	true

	_ ->
	false
	end
	end

	@doc "Expand and authorizes a stream"
	@spec get_topic(stream :: String.t() \| nil, User.t() \| nil, Token.t() \| nil, map()) ::
	{:ok, topic :: String.t() \| nil} \| {:error, :bad_topic}
	def get_topic(stream, user, oauth_token, params \\ %{})

	def get_topic(nil = _stream, _user, _oauth_token, _params) do
	{:ok, nil}
	end

	# Allow all public steams if the instance allows unauthenticated access.
	# Otherwise, only allow users with valid oauth tokens.
	def get_topic(stream, user, oauth_token, _params) when stream in @public_streams do
	kind = if stream in @local_streams, do: :local, else: :federated

	if can_access_stream(user, oauth_token, kind) do
	{:ok, stream}
	else
	{:error, :unauthorized}
	end
	end

	# Allow all hashtags streams.
	def get_topic("hashtag", _user, _oauth_token, %{"tag" => tag} = _params) do
	{:ok, "hashtag:" <> tag}
	end

	# Allow remote instance streams.
	def get_topic("public:remote", user, oauth_token, %{"instance" => instance} = _params) do
	if can_access_stream(user, oauth_token, :federated) do
	{:ok, "public:remote:" <> instance}
	else
	{:error, :unauthorized}
	end
	end

	def get_topic("public:remote:media", user, oauth_token, %{"instance" => instance} = _params) do
	if can_access_stream(user, oauth_token, :federated) do
	{:ok, "public:remote:media:" <> instance}
	else
	{:error, :unauthorized}
	end
	end

	# Expand user streams.
	def get_topic(
	stream,
	%User{id: user_id} = user,
	%Token{user_id: user_id} = oauth_token,
	_params
	)
	when stream in @user_streams do
	# Note: "read" works for all user streams (not mentioning it since it's an ancestor scope)
	required_scopes =
	if stream == "user:notification" do
	["read:notifications"]
	else
	["read:statuses"]
	end

	if OAuthScopesPlug.filter_descendants(required_scopes, oauth_token.scopes) == [] do
	{:error, :unauthorized}
	else
	{:ok, stream <> ":" <> to_string(user.id)}
	end
	end

	def get_topic(stream, _user, _oauth_token, _params) when stream in @user_streams do
	{:error, :unauthorized}
	end

	# List streams.
	def get_topic(
	"list",
	%User{id: user_id} = user,
	%Token{user_id: user_id} = oauth_token,
	%{"list" => id}
	) do
	cond do
	OAuthScopesPlug.filter_descendants(["read", "read:lists"], oauth_token.scopes) == [] ->
	{:error, :unauthorized}

	Pleroma.List.get(id, user) ->
	{:ok, "list:" <> to_string(id)}

	true ->
	{:error, :bad_topic}
	end
	end

	def get_topic("list", _user, _oauth_token, _params) do
	{:error, :unauthorized}
	end

	def get_topic(_stream, _user, _oauth_token, _params) do
	{:error, :bad_topic}
	end

	@doc "Registers the process for streaming. Use `get_topic/3` to get the full authorized topic."
	def add_socket(topic, oauth_token) do
	if should_env_send?() do
	oauth_token_id = if oauth_token, do: oauth_token.id, else: false
	Registry.register(@registry, topic, oauth_token_id)
	end

	{:ok, topic}
	end

	def remove_socket(topic) do
	if should_env_send?(), do: Registry.unregister(@registry, topic)
	end

	def stream(topics, items) do
	if should_env_send?() do
	for topic <- List.wrap(topics), item <- List.wrap(items) do
	fun = fn -> do_stream(topic, item) end

	if Config.get([__MODULE__, :sync_streaming], false) do
	fun.()
	else
	spawn(fun)
	end
	end
	end
	end

	def filtered_by_user?(user, item, streamed_type \\ :activity)

	def filtered_by_user?(%User{} = user, %Activity{} = item, streamed_type) do
	%{block: blocked_ap_ids, mute: muted_ap_ids, reblog_mute: reblog_muted_ap_ids} =
	User.outgoing_relationships_ap_ids(user, [:block, :mute, :reblog_mute])

	recipient_blocks = MapSet.new(blocked_ap_ids ++ muted_ap_ids)
	recipients = MapSet.new(item.recipients)
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)

	with parent <- Object.normalize(item, fetch: false) \|\| item,
	true <- Enum.all?([blocked_ap_ids, muted_ap_ids], &(item.actor not in &1)),
	true <- item.data["type"] != "Announce" \|\| item.actor not in reblog_muted_ap_ids,
	true <-
	!(streamed_type == :activity && item.data["type"] == "Announce" &&
	parent.data["actor"] == user.ap_id),
	true <- Enum.all?([blocked_ap_ids, muted_ap_ids], &(parent.data["actor"] not in &1)),
	true <- MapSet.disjoint?(recipients, recipient_blocks),
	%{host: item_host} <- URI.parse(item.actor),
	%{host: parent_host} <- URI.parse(parent.data["actor"]),
	false <- Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, item_host),
	false <- Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, parent_host),
	true <- thread_containment(item, user),
	false <- CommonAPI.thread_muted?(parent, user) do
	false
	else
	_ -> true
	end
	end

	def filtered_by_user?(%User{} = user, %Notification{activity: activity}, _) do
	filtered_by_user?(user, activity, :notification)
	end

	defp do_stream("direct", item) do
	recipient_topics =
	User.get_recipients_from_activity(item)
	\|> Enum.map(fn %{id: id} -> "direct:#{id}" end)

	Enum.each(recipient_topics, fn user_topic ->
	Logger.debug("Trying to push direct message to #{user_topic}\n\n")
	push_to_socket(user_topic, item)
	end)
	end

	defp do_stream("follow_relationship", item) do
	user_topic = "user:#{item.follower.id}"
	text = StreamerView.render("follow_relationships_update.json", item, user_topic)

	Logger.debug("Trying to push follow relationship update to #{user_topic}\n\n")

	Registry.dispatch(@registry, user_topic, fn list ->
	Enum.each(list, fn {pid, _auth} ->
	send(pid, {:text, text})
	end)
	end)
	end

	defp do_stream("participation", participation) do
	user_topic = "direct:#{participation.user_id}"
	Logger.debug("Trying to push a conversation participation to #{user_topic}\n\n")

	push_to_socket(user_topic, participation)
	end

	defp do_stream("list", item) do
	# filter the recipient list if the activity is not public, see #270.
	recipient_lists =
	case Visibility.public?(item) do
	true ->
	Pleroma.List.get_lists_from_activity(item)

	_ ->
	Pleroma.List.get_lists_from_activity(item)
	\|> Enum.filter(fn list ->
	owner = User.get_cached_by_id(list.user_id)

	Visibility.visible_for_user?(item, owner)
	end)
	end

	recipient_topics =
	recipient_lists
	\|> Enum.map(fn %{id: id} -> "list:#{id}" end)

	Enum.each(recipient_topics, fn list_topic ->
	Logger.debug("Trying to push message to #{list_topic}\n\n")
	push_to_socket(list_topic, item)
	end)
	end

	defp do_stream(topic, %Notification{} = item)
	when topic in ["user", "user:notification"] do
	user_topic = "#{topic}:#{item.user_id}"

	Registry.dispatch(@registry, user_topic, fn list ->
	Enum.each(list, fn {pid, _auth} ->
	send(pid, {:render_with_user, StreamerView, "notification.json", item, user_topic})
	end)
	end)
	end

	defp do_stream(topic, {user, %MessageReference{} = cm_ref})
	when topic in ["user", "user:pleroma_chat"] do
	topic = "#{topic}:#{user.id}"

	text = StreamerView.render("chat_update.json", %{chat_message_reference: cm_ref}, topic)

	Registry.dispatch(@registry, topic, fn list ->
	Enum.each(list, fn {pid, _auth} ->
	send(pid, {:text, text})
	end)
	end)
	end

	- defp do_stream("user", item) do
	+ defp do_stream("user", %Activity{} = item) do
	Logger.debug("Trying to push to users")

	recipient_topics =
	User.get_recipients_from_activity(item)
	\|> Enum.map(fn %{id: id} -> "user:#{id}" end)

	hashtag_recipients =
	if Pleroma.Constants.as_public() in item.recipients do
	Pleroma.Hashtag.get_recipients_for_activity(item)
	\|> Enum.map(fn id -> "user:#{id}" end)
	else
	[]
	end

	all_recipients = Enum.uniq(recipient_topics ++ hashtag_recipients)

	Enum.each(all_recipients, fn topic ->
	push_to_socket(topic, item)
	end)
	end

	defp do_stream(topic, %Marker{} = marker) do
	Registry.dispatch(@registry, "#{topic}:#{marker.user_id}", fn list ->
	Enum.each(list, fn {pid, _auth} ->
	text = StreamerView.render("marker.json", marker)

	send(pid, {:text, text})
	end)
	end)
	end

	defp do_stream(topic, item) do
	Logger.debug("Trying to push to #{topic}")
	Logger.debug("Pushing item to #{topic}")
	push_to_socket(topic, item)
	end

	defp push_to_socket(topic, %Participation{} = participation) do
	rendered = StreamerView.render("conversation.json", participation, topic)

	Registry.dispatch(@registry, topic, fn list ->
	Enum.each(list, fn {pid, _} ->
	send(pid, {:text, rendered})
	end)
	end)
	end

	defp push_to_socket(topic, %Activity{
	data: %{"type" => "Delete", "deleted_activity_id" => deleted_activity_id}
	}) do
	rendered = Jason.encode!(%{event: "delete", payload: to_string(deleted_activity_id)})

	Registry.dispatch(@registry, topic, fn list ->
	Enum.each(list, fn {pid, _} ->
	send(pid, {:text, rendered})
	end)
	end)
	end

	defp push_to_socket(_topic, %Activity{data: %{"type" => "Delete"}}), do: :noop

	defp push_to_socket(topic, %Activity{data: %{"type" => "Update"}} = item) do
	create_activity =
	Pleroma.Activity.get_create_by_object_ap_id(item.object.data["id"])
	\|> Map.put(:object, item.object)

	anon_render = StreamerView.render("status_update.json", create_activity, topic)

	Registry.dispatch(@registry, topic, fn list ->
	Enum.each(list, fn {pid, auth?} ->
	if auth? do
	send(
	pid,
	{:render_with_user, StreamerView, "status_update.json", create_activity, topic}
	)
	else
	send(pid, {:text, anon_render})
	end
	end)
	end)
	end

	defp push_to_socket(topic, item) do
	anon_render = StreamerView.render("update.json", item, topic)

	Registry.dispatch(@registry, topic, fn list ->
	Enum.each(list, fn {pid, auth?} ->
	if auth? do
	send(pid, {:render_with_user, StreamerView, "update.json", item, topic})
	else
	send(pid, {:text, anon_render})
	end
	end)
	end)
	end

	defp thread_containment(_activity, %User{skip_thread_containment: true}), do: true

	defp thread_containment(activity, user) do
	if Config.get([:instance, :skip_thread_containment]) do
	true
	else
	ActivityPub.contain_activity(activity, user)
	end
	end

	def close_streams_by_oauth_token(oauth_token) do
	if should_env_send?() do
	Registry.select(
	@registry,
	[
	{
	{:"$1", :"$2", :"$3"},
	[{:==, :"$3", oauth_token.id}],
	[:"$2"]
	}
	]
	)
	\|> Enum.each(fn pid -> send(pid, :close) end)
	end
	end

	# In dev/prod the streamer registry is expected to be started, so return true
	# In test it is possible to have the registry started for a test so it will check
	# In benchmark it will never find the process alive and return false
	def should_env_send? do
	if Application.get_env(:pleroma, Pleroma.Application)[:streamer_registry] do
	true
	else
	case Process.whereis(@registry) do
	nil ->
	false

	pid ->
	Process.alive?(pid)
	end
	end
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 9e7ce7d4e..21ddcfd0c 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,368 +1,368 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.10.0"),
	elixir: "~> 1.15",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors(), prune_code_paths: false],
	xref: [exclude: [:eldap]],
	dialyzer: [plt_add_apps: [:mix, :eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: :covertool, summary: true],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/images/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
	steps: [:assemble, &copy_files/1, &copy_nginx_config/1],
	config_providers: [{Pleroma.Config.ReleaseRuntimeProvider, []}]
	]
	]
	]
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications:
	[
	:logger,
	:runtime_tools,
	:comeonin,
	:fast_sanitize,
	:os_mon,
	:ssl,
	:eldap
	] ++ logger_application(),
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:benchmark), do: ["lib", "benchmarks", "priv/scrubbers"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors, do: System.get_env("CI") == "true"

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	defp logger_application do
	if Version.match?(System.version(), "<1.15.0-rc.0") do
	[]
	else
	[:logger_backends]
	end
	end

	defp logger_deps do
	if Version.match?(System.version(), "<1.15.0-rc.0") do
	[]
	else
	[{:logger_backends, "~> 1.0"}]
	end
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix,
	git: "https://github.com/feld/phoenix", branch: "v1.7.14-websocket-headers", override: true},
	{:phoenix_ecto, "~> 4.4"},
	{:ecto_sql, "~> 3.10"},
	{:ecto_enum, "~> 1.4"},
	{:postgrex, ">= 0.20.0"},
	{:phoenix_html, "~> 3.3"},
	{:phoenix_live_view, "~> 0.19.0"},
	{:phoenix_live_dashboard, "~> 0.8.0"},
	{:telemetry_metrics, "~> 0.6"},
	{:telemetry_poller, "~> 1.0"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.7"},
	{:oban, "~> 2.19.0"},
	{:oban_plugins_lazarus,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/oban_plugins_lazarus.git",
	ref: "e49fc355baaf0e435208bf5f534d31e26e897711"},
	{:gettext, "~> 0.20"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{:calendar, "~> 1.0"},
	{:cachex, "~> 3.2"},
	{:tesla, "~> 1.11"},
	{:castore, "~> 1.0"},
	{:cowlib, "~> 2.15"},
	{:gun, "~> 2.2"},
	{:finch, "~> 0.15"},
	{:jason, "~> 1.2"},
	{:mogrify, "~> 0.9.0", override: "true"},
	{:ex_aws, "~> 2.1.6"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.7.2"},
	{:earmark, "1.4.46"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption, "~> 0.3.1"},
	{:swoosh, "~> 1.16.9"},
	{:phoenix_swoosh, "~> 1.1"},
	{:gen_smtp, "~> 0.13"},
	{:mua, "~> 0.2.0"},
	{:mail, "~> 0.3.0"},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.35"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.5.3"},
	{:http_signatures, "~> 0.1.2"},
	{:telemetry, "~> 1.0.0", override: true},
	{:poolboy, "~> 1.5"},
	{:prom_ex, "~> 1.9"},
	{:recon, "~> 2.5"},
	{:joken, "~> 2.0"},
	{:pot, "~> 1.0"},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter, "~> 0.1.1"},
	{:remote_ip,
	git: "https://git.pleroma.social/pleroma/remote_ip.git",
	ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
	{:captcha,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
	ref: "e7b7cc34cc16b383461b966484c297e4ec9aeef6"},
	{:restarter, path: "./restarter"},
	{:majic, "~> 1.0"},
	{:open_api_spex, "~> 3.16"},
	{:ecto_psql_extras, "~> 0.8"},
	{:vix, "~> 0.26.0"},
	{:elixir_make, "~> 0.7.7", override: true},
	{:blurhash, "~> 0.1.0", hex: :rinpatch_blurhash},
	{:exile, "~> 0.10.0"},
	{:bandit, "~> 1.5.2"},
	{:websock_adapter, "~> 0.5.6"},
	{:oban_live_dashboard, "~> 0.1.1"},
	{:multipart, "~> 0.4.0", optional: true},
	{:argon2_elixir, "~> 4.0"},

	## dev & test
	{:phoenix_live_reload, "~> 1.3.3", only: :dev},
	{:poison, "~> 3.0", only: :test},
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.7", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	{:covertool, "~> 2.0", only: :test},
	{:hackney, "~> 1.18.0", override: true},
	{:mox, "~> 1.0", only: :test},
	{:websockex, "~> 0.4.3", only: :test},
	{:benchee, "~> 1.0", only: :benchmark},
	{:dialyxir, "~> 1.4", only: [:dev, :test], runtime: false}
	] ++ oauth_deps() ++ logger_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	- test: ["ecto.create --quiet", "ecto.migrate", "test --warnings-as-errors"],
	+ test: ["ecto.create --quiet", "pleroma.ecto.migrate --quiet", "test --warnings-as-errors"],
	docs: ["pleroma.docs", "docs"],
	analyze: ["credo --strict --only=warnings,todo,fixme,consistency,readability"],
	copyright: &add_copyright/1,
	"copyright.bump": &bump_copyright/1
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	git_available? = match?({_output, 0}, System.cmd("sh", ["-c", "command -v git"]))
	dotgit_present? = File.exists?(".git")

	git_pre_release =
	if git_available? and dotgit_present? do
	{tag, tag_err} =
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true)

	{describe, describe_err} = System.cmd("git", ["describe", "--tags", "--abbrev=8"])
	{commit_hash, commit_hash_err} = System.cmd("git", ["rev-parse", "--short", "HEAD"])

	# Pre-release version, denoted from patch version with a hyphen
	cond do
	tag_err == 0 and describe_err == 0 ->
	describe
	\|> String.trim()
	\|> String.replace(String.trim(tag), "")
	\|> String.trim_leading("-")
	\|> String.trim()

	commit_hash_err == 0 ->
	"0-g" <> String.trim(commit_hash)

	true ->
	nil
	end
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with true <- git_available?,
	true <- dotgit_present?,
	{branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <-
	!Enum.any?(["master", "HEAD", "release/", "stable"], fn name ->
	String.starts_with?(name, branch_name)
	end) do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	else
	_ -> ""
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end

	defp add_copyright(_) do
	year = NaiveDateTime.utc_now().year
	template = ~s[\
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	] \|> String.replace("\n", "\\n")

	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$ -exec "
	grep = "grep -L '# Copyright © [0-9\-]* Pleroma' {} \\;"
	xargs = "xargs -n1 sed -i'' '1s;^;#{template};'"

	:os.cmd(String.to_charlist("#{find}#{grep} \| #{xargs}"))
	end

	defp bump_copyright(_) do
	year = NaiveDateTime.utc_now().year
	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$"

	xargs =
	"xargs sed -i'' 's;# Copyright © [0-9\-]* Pleroma.*$;# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>;'"

	:os.cmd(String.to_charlist("#{find} \| #{xargs}"))
	end
	end
	diff --git a/test/mix/pleroma_test.exs b/test/mix/pleroma_test.exs
	index e362223b2..e8f801913 100644
	--- a/test/mix/pleroma_test.exs
	+++ b/test/mix/pleroma_test.exs
	@@ -1,50 +1,50 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.PleromaTest do
	- use ExUnit.Case, async: true
	+ use ExUnit.Case, async: false
	import Mix.Pleroma

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

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

	:ok
	end

	describe "shell_prompt/1" do
	test "input" do
	send(self(), {:mix_shell_input, :prompt, "Yes"})

	answer = shell_prompt("Do you want this?")
	assert_received {:mix_shell, :prompt, [message]}
	assert message =~ "Do you want this?"
	assert answer == "Yes"
	end

	test "with defval" do
	send(self(), {:mix_shell_input, :prompt, "\n"})

	answer = shell_prompt("Do you want this?", "defval")

	assert_received {:mix_shell, :prompt, [message]}
	assert message =~ "Do you want this? [defval]"
	assert answer == "defval"
	end
	end

	describe "get_option/3" do
	test "get from options" do
	assert get_option([domain: "some-domain.com"], :domain, "Prompt") == "some-domain.com"
	end

	test "get from prompt" do
	send(self(), {:mix_shell_input, :prompt, "another-domain.com"})
	assert get_option([], :domain, "Prompt") == "another-domain.com"
	end
	end
	end
	diff --git a/test/mix/tasks/pleroma/app_test.exs b/test/mix/tasks/pleroma/app_test.exs
	index 65245eadd..6156214c1 100644
	--- a/test/mix/tasks/pleroma/app_test.exs
	+++ b/test/mix/tasks/pleroma/app_test.exs
	@@ -1,66 +1,66 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.AppTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

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

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

	describe "creates new app" do
	test "with default scopes" do
	name = "Some name"
	redirect = "https://example.com"
	Mix.Tasks.Pleroma.App.run(["create", "-n", name, "-r", redirect])

	assert_app(name, redirect, ["read", "write", "follow", "push"])
	end

	test "with custom scopes" do
	name = "Another name"
	redirect = "https://example.com"

	Mix.Tasks.Pleroma.App.run([
	"create",
	"-n",
	name,
	"-r",
	redirect,
	"-s",
	"read,write,follow,push,admin"
	])

	assert_app(name, redirect, ["read", "write", "follow", "push", "admin"])
	end
	end

	test "with errors" do
	Mix.Tasks.Pleroma.App.run(["create"])

	assert_receive {:mix_shell, :error, ["Creating failed:"]}
	assert_receive {:mix_shell, :error, ["name: can't be blank"]}
	assert_receive {:mix_shell, :error, ["redirect_uris: can't be blank"]}
	end

	defp assert_app(name, redirect, scopes) do
	app = Repo.get_by(Pleroma.Web.OAuth.App, client_name: name)

	assert_receive {:mix_shell, :info, [message]}
	assert message == "#{name} successfully created:"

	assert_receive {:mix_shell, :info, [message]}
	assert message == "App client_id: #{app.client_id}"

	assert_receive {:mix_shell, :info, [message]}
	assert message == "App client_secret: #{app.client_secret}"

	assert app.scopes == scopes
	assert app.redirect_uris == redirect
	end
	end
	diff --git a/test/mix/tasks/pleroma/database_test.exs b/test/mix/tasks/pleroma/database_test.exs
	index 38ed096ae..19df17b60 100644
	--- a/test/mix/tasks/pleroma/database_test.exs
	+++ b/test/mix/tasks/pleroma/database_test.exs
	@@ -1,660 +1,660 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.DatabaseTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

	:ok
	end

	describe "running remove_embedded_objects" do
	test "it replaces objects with references" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "test"})
	new_data = Map.put(activity.data, "object", activity.object.data)

	{:ok, activity} =
	activity
	\|> Activity.change(%{data: new_data})
	\|> Repo.update()

	assert is_map(activity.data["object"])

	Mix.Tasks.Pleroma.Database.run(["remove_embedded_objects"])

	activity = Activity.get_by_id_with_object(activity.id)
	assert is_binary(activity.data["object"])
	end
	end

	describe "prune_objects" do
	setup do
	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days]) + 1

	old_insert_date =
	Timex.now()
	\|> Timex.shift(days: -deadline)
	\|> Timex.to_naive_datetime()
	\|> NaiveDateTime.truncate(:second)

	%{old_insert_date: old_insert_date}
	end

	test "it prunes old objects from the database", %{old_insert_date: old_insert_date} do
	insert(:note)

	%{id: note_remote_public_id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	note_remote_non_public =
	%{id: note_remote_non_public_id, data: note_remote_non_public_data} =
	:note
	\|> insert()

	note_remote_non_public
	\|> Ecto.Changeset.change(%{
	updated_at: old_insert_date,
	data: note_remote_non_public_data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	refute Object.get_by_id(note_remote_public_id)
	refute Object.get_by_id(note_remote_non_public_id)
	end

	test "it cleans up bookmarks", %{old_insert_date: old_insert_date} do
	user = insert(:user)
	{:ok, old_object_activity} = CommonAPI.post(user, %{status: "yadayada"})

	Repo.one(Object)
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, new_object_activity} = CommonAPI.post(user, %{status: "yadayada"})

	{:ok, _} = Bookmark.create(user.id, old_object_activity.id)
	{:ok, _} = Bookmark.create(user.id, new_object_activity.id)

	assert length(Repo.all(Object)) == 2
	assert length(Repo.all(Bookmark)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	assert length(Repo.all(Bookmark)) == 1
	refute Bookmark.get(user.id, old_object_activity.id)
	end

	test "with the --keep-non-public option it still keeps non-public posts even if they are not local",
	%{old_insert_date: old_insert_date} do
	insert(:note)

	%{id: note_remote_id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	note_remote_non_public =
	%{data: note_remote_non_public_data} =
	:note
	\|> insert()

	note_remote_non_public
	\|> Ecto.Changeset.change(%{
	updated_at: old_insert_date,
	data: note_remote_non_public_data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-non-public"])

	assert length(Repo.all(Object)) == 2
	refute Object.get_by_id(note_remote_id)
	end

	test "with the --keep-threads and --keep-non-public option it keeps old threads with non-public replies even if the interaction is not local",
	%{old_insert_date: old_insert_date} do
	# For non-public we only check Create Activities because only these are relevant for threads
	# Flags are always non-public, Announces from relays can be non-public...

	remote_user1 = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	# Old remote non-public reply (should be kept)
	{:ok, old_remote_post1_activity} =
	CommonAPI.post(remote_user1, %{status: "some thing", local: false})

	old_remote_post1_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_non_public_reply_activity} =
	CommonAPI.post(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post1_activity.id
	})

	old_remote_non_public_reply_activity
	\|> Ecto.Changeset.change(%{
	local: false,
	updated_at: old_insert_date,
	data: old_remote_non_public_reply_activity.data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	# Old remote non-public Announce (should be removed)
	{:ok, old_remote_post2_activity = %{data: %{"object" => old_remote_post2_id}}} =
	CommonAPI.post(remote_user1, %{status: "some thing", local: false})

	old_remote_post2_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_non_public_repeat_activity} =
	CommonAPI.repeat(old_remote_post2_activity.id, remote_user2)

	old_remote_non_public_repeat_activity
	\|> Ecto.Changeset.change(%{
	local: false,
	updated_at: old_insert_date,
	data: old_remote_non_public_repeat_activity.data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads", "--keep-non-public"])

	Repo.all(Pleroma.Activity)
	assert length(Repo.all(Object)) == 2
	refute Object.get_by_ap_id(old_remote_post2_id)
	end

	test "with the --keep-threads option it still keeps non-old threads even with no local interactions" do
	remote_user = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	{:ok, remote_post_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	{:ok, remote_post_reply_activity} =
	CommonAPI.post(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: remote_post_activity.id
	})

	remote_post_activity
	\|> Ecto.Changeset.change(%{local: false})
	\|> Repo.update!()

	remote_post_reply_activity
	\|> Ecto.Changeset.change(%{local: false})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 2
	end

	test "with the --keep-threads option it deletes old threads with no local interaction", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	{:ok, old_remote_post_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_post_reply_activity} =
	CommonAPI.post(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post_activity.id
	})

	old_remote_post_reply_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_favourite_activity} =
	CommonAPI.favorite(old_remote_post_activity.id, remote_user2)

	old_favourite_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_repeat_activity} = CommonAPI.repeat(old_remote_post_activity.id, remote_user2)

	old_repeat_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 0
	end

	test "with the --keep-threads option it keeps old threads with local interaction", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	local_user = insert(:user, local: true)

	# local reply
	{:ok, old_remote_post1_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post1_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_local_post2_reply_activity} =
	CommonAPI.post(local_user, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post1_activity.id
	})

	old_local_post2_reply_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	# local Like
	{:ok, old_remote_post3_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post3_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_favourite_activity} = CommonAPI.favorite(old_remote_post3_activity.id, local_user)

	old_favourite_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	# local Announce
	{:ok, old_remote_post4_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post4_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_repeat_activity} = CommonAPI.repeat(old_remote_post4_activity.id, local_user)

	old_repeat_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 4

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 4
	end

	test "with the --keep-threads option it keeps old threads with bookmarked posts", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	local_user = insert(:user, local: true)

	{:ok, old_remote_post_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	Pleroma.Bookmark.create(local_user.id, old_remote_post_activity.id)

	assert length(Repo.all(Object)) == 1

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 1
	end

	test "We don't have unexpected tables which may contain objects that are referenced by activities" do
	# We can delete orphaned activities. For that we look for the objects
	# they reference in the 'objects', 'activities', and 'users' table.
	# If someone adds another table with objects (idk, maybe with separate
	# relations, or collections or w/e), then we need to make sure we
	# add logic for that in the 'prune_objects' task so that we don't
	# wrongly delete their corresponding activities.
	# So when someone adds (or removes) a table, this test will fail.
	# Either the table contains objects which can be referenced from the
	# activities table
	# => in that case the prune_objects job should be adapted so we don't
	# delete activities who still have the referenced object.
	# Or it doesn't contain objects which can be referenced from the activities table
	# => in that case you can add/remove the table to/from this (sorted) list.

	assert Repo.query!(
	"SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';"
	).rows
	\|> Enum.sort() == [
	["activities"],
	["announcement_read_relationships"],
	["announcements"],
	["apps"],
	["backups"],
	["bookmark_folders"],
	["bookmarks"],
	["chat_message_references"],
	["chats"],
	["config"],
	["conversation_participation_recipient_ships"],
	["conversation_participations"],
	["conversations"],
	["counter_cache"],
	["data_migration_failed_ids"],
	["data_migrations"],
	["deliveries"],
	["filters"],
	["following_relationships"],
	["hashtags"],
	["hashtags_objects"],
	["instances"],
	["lists"],
	["markers"],
	["mfa_tokens"],
	["moderation_log"],
	["notifications"],
	["oauth_authorizations"],
	["oauth_tokens"],
	["oban_jobs"],
	["oban_peers"],
	["objects"],
	["password_reset_tokens"],
	["push_subscriptions"],
	["registrations"],
	["report_notes"],
	["rich_media_card"],
	["rules"],
	["scheduled_activities"],
	["schema_migrations"],
	["thread_mutes"],
	["user_follows_hashtag"],
	# ["user_frontend_setting_profiles"], # not in pleroma
	["user_invite_tokens"],
	["user_notes"],
	["user_relationships"],
	["users"]
	]
	end

	test "it prunes orphaned activities with the --prune-orphaned-activities" do
	# Add a remote activity which references an Object
	%Object{} \|> Map.merge(%{data: %{"id" => "object_for_activity"}}) \|> Repo.insert()

	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{"id" => "remote_activity_with_object", "object" => "object_for_activity"}
	})
	\|> Repo.insert()

	# Add a remote activity which references an activity
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_with_activity",
	"object" => "remote_activity_with_object"
	}
	})
	\|> Repo.insert()

	# Add a remote activity which references an Actor
	%User{} \|> Map.merge(%{ap_id: "actor"}) \|> Repo.insert()

	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{"id" => "remote_activity_with_actor", "object" => "actor"}
	})
	\|> Repo.insert()

	# Add a remote activity without existing referenced object, activity or actor
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_without_existing_referenced_object",
	"object" => "non_existing"
	}
	})
	\|> Repo.insert()

	# Add a local activity without existing referenced object, activity or actor
	%Activity{}
	\|> Map.merge(%{
	local: true,
	data: %{"id" => "local_activity_with_actor", "object" => "non_existing"}
	})
	\|> Repo.insert()

	# The remote activities without existing reference,
	# and only the remote activities without existing reference, are deleted
	# if, and only if, we provide the --prune-orphaned-activities option
	assert length(Repo.all(Activity)) == 5
	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Activity)) == 5
	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--prune-orphaned-activities"])
	activities = Repo.all(Activity)

	assert "remote_activity_without_existing_referenced_object" not in Enum.map(
	activities,
	fn a -> a.data["id"] end
	)

	assert length(activities) == 4
	end

	test "it prunes orphaned activities with the --prune-orphaned-activities when the objects are referenced from an array" do
	%Object{} \|> Map.merge(%{data: %{"id" => "existing_object"}}) \|> Repo.insert()
	%User{} \|> Map.merge(%{ap_id: "existing_actor"}) \|> Repo.insert()

	# Multiple objects, one object exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_object",
	"object" => ["non_ existing_object", "existing_object"]
	}
	})
	\|> Repo.insert()

	# Multiple objects, one actor exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_actor",
	"object" => ["non_ existing_object", "existing_actor"]
	}
	})
	\|> Repo.insert()

	# Multiple objects, one activity exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_activity",
	"object" => ["non_ existing_object", "remote_activity_existing_actor"]
	}
	})
	\|> Repo.insert()

	# Multiple objects none exist (prune)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_without_existing_referenced_object",
	"object" => ["owo", "whats_this"]
	}
	})
	\|> Repo.insert()

	assert length(Repo.all(Activity)) == 4
	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Activity)) == 4
	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--prune-orphaned-activities"])
	activities = Repo.all(Activity)
	assert length(activities) == 3

	assert "remote_activity_without_existing_referenced_object" not in Enum.map(
	activities,
	fn a -> a.data["id"] end
	)

	assert length(activities) == 3
	end
	end

	describe "running update_users_following_followers_counts" do
	test "following and followers count are updated" do
	[user, user2] = insert_pair(:user)
	{:ok, %User{} = user, _user2} = User.follow(user, user2)

	following = User.following(user)

	assert length(following) == 2
	assert user.follower_count == 0

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{follower_count: 3})
	\|> Repo.update()

	assert user.follower_count == 3

	assert {:ok, :ok} ==
	Mix.Tasks.Pleroma.Database.run(["update_users_following_followers_counts"])

	user = User.get_by_id(user.id)

	assert length(User.following(user)) == 2
	assert user.follower_count == 0
	end
	end

	describe "running fix_likes_collections" do
	test "it turns OrderedCollection likes into empty arrays" do
	[user, user2] = insert_pair(:user)

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

	CommonAPI.favorite(id, user2)

	likes = %{
	"first" =>
	"http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
	"id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
	"totalItems" => 3,
	"type" => "OrderedCollection"
	}

	new_data = Map.put(object2.data, "likes", likes)

	object2
	\|> Ecto.Changeset.change(%{data: new_data})
	\|> Repo.update()

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert is_map(Object.get_by_id(object2.id).data["likes"])

	assert :ok == Mix.Tasks.Pleroma.Database.run(["fix_likes_collections"])

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert Enum.empty?(Object.get_by_id(object2.id).data["likes"])
	end
	end

	describe "ensure_expiration" do
	test "it adds to expiration old statuses" do
	activity1 = insert(:note_activity)

	{:ok, inserted_at, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
	activity2 = insert(:note_activity, %{inserted_at: inserted_at})

	%{id: activity_id3} = insert(:note_activity)

	expires_at = DateTime.add(DateTime.utc_now(), 60 * 61)

	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: activity_id3
	},
	scheduled_at: expires_at
	)

	Mix.Tasks.Pleroma.Database.run(["ensure_expiration"])

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity1.id},
	scheduled_at:
	activity1.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity2.id},
	scheduled_at:
	activity2.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity_id3},
	scheduled_at: expires_at
	)
	end
	end
	end
	diff --git a/test/pleroma/http_test.exs b/test/pleroma/http_test.exs
	index 7b6847cf9..e673e6591 100644
	--- a/test/pleroma/http_test.exs
	+++ b/test/pleroma/http_test.exs
	@@ -1,217 +1,217 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTPTest do
	- use ExUnit.Case, async: true
	+ use ExUnit.Case, async: false
	use Pleroma.Tests.Helpers

	import Tesla.Mock

	alias Pleroma.HTTP
	alias Pleroma.Utils.URIEncoding

	setup do
	mock(fn
	%{
	method: :get,
	url: "http://example.com/hello",
	headers: [{"content-type", "application/json"}]
	} ->
	json(%{"my" => "data"})

	%{method: :head, url: "http://example.com/hello"} ->
	%Tesla.Env{status: 200, body: ""}

	%{method: :get, url: "http://example.com/hello"} ->
	%Tesla.Env{status: 200, body: "hello"}

	%{method: :post, url: "http://example.com/world"} ->
	%Tesla.Env{status: 200, body: "world"}

	%{method: :get, url: "https://example.com/emoji/Pack%201/koronebless.png?foo=bar+baz"} ->
	%Tesla.Env{status: 200, body: "emoji data"}

	%{
	method: :get,
	url: "https://example.com/media/foo/bar%20!$&'()*+,;=/:%20@a%20%5Bbaz%5D.mp4"
	} ->
	%Tesla.Env{status: 200, body: "video data"}

	%{method: :get, url: "https://example.com/media/unicode%20%F0%9F%99%82%20.gif"} ->
	%Tesla.Env{status: 200, body: "unicode data"}

	%{
	method: :get,
	url:
	"https://i.guim.co.uk/img/media/1069ef13c447908272c4de94174cec2b6352cb2f/0_91_2000_1201/master/2000.jpg?width=1200&height=630&quality=85&auto=format&fit=crop&precrop=40:21,offset-x50,offset-y0&overlay-align=bottom%2Cleft&overlay-width=100p&overlay-base64=L2ltZy9zdGF0aWMvb3ZlcmxheXMvdGctb3BpbmlvbnMtYWdlLTIwMTkucG5n&enable=upscale&s=cba21427a73512fdc9863c486c03fdd8"
	} ->
	%Tesla.Env{status: 200, body: "Guardian image quirk"}

	%{
	method: :get,
	url:
	"https://i.guim.co.uk/emoji/Pack%201/koronebless.png?precrop=40:21,overlay-x0,overlay-y0&foo=bar+baz"
	} ->
	%Tesla.Env{status: 200, body: "Space in query with Guardian quirk"}

	%{
	method: :get,
	url:
	"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=accessKEY%2F20130721%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20130721T201207Z&X-Amz-Expires=86400&X-Amz-Signature=SIGNATURE&X-Amz-SignedHeaders=host"
	} ->
	%Tesla.Env{status: 200, body: "AWS S3 data"}
	end)

	:ok
	end

	describe "head/1" do
	test "returns successfully result" do
	assert HTTP.head("http://example.com/hello") == {:ok, %Tesla.Env{status: 200, body: ""}}
	end
	end

	describe "get/1" do
	test "returns successfully result" do
	assert HTTP.get("http://example.com/hello") == {
	:ok,
	%Tesla.Env{status: 200, body: "hello"}
	}
	end
	end

	describe "get/2 (with headers)" do
	test "returns successfully result for json content-type" do
	assert HTTP.get("http://example.com/hello", [{"content-type", "application/json"}]) ==
	{
	:ok,
	%Tesla.Env{
	status: 200,
	body: "{\"my\":\"data\"}",
	headers: [{"content-type", "application/json"}]
	}
	}
	end
	end

	describe "post/2" do
	test "returns successfully result" do
	assert HTTP.post("http://example.com/world", "") == {
	:ok,
	%Tesla.Env{status: 200, body: "world"}
	}
	end
	end

	test "URL encoding properly encodes URLs with spaces" do
	clear_config(:test_url_encoding, true)

	url_with_space = "https://example.com/emoji/Pack 1/koronebless.png?foo=bar baz"

	{:ok, result} = HTTP.get(url_with_space)

	assert result.status == 200

	properly_encoded_url = "https://example.com/emoji/Pack%201/koronebless.png?foo=bar+baz"

	{:ok, result} = HTTP.get(properly_encoded_url)

	assert result.status == 200

	url_with_reserved_chars = "https://example.com/media/foo/bar !$&'()*+,;=/: @a [baz].mp4"

	{:ok, result} = HTTP.get(url_with_reserved_chars)

	assert result.status == 200

	url_with_unicode = "https://example.com/media/unicode 🙂 .gif"

	{:ok, result} = HTTP.get(url_with_unicode)

	assert result.status == 200
	end

	test "decodes URL first by default" do
	clear_config(:test_url_encoding, true)

	normal_url = "https://example.com/media/file%20with%20space.jpg?name=a+space.jpg"

	result = URIEncoding.encode_url(normal_url)

	assert result == "https://example.com/media/file%20with%20space.jpg?name=a+space.jpg"
	end

	test "doesn't decode URL first when specified" do
	clear_config(:test_url_encoding, true)

	normal_url = "https://example.com/media/file%20with%20space.jpg"

	result = URIEncoding.encode_url(normal_url, bypass_decode: true)

	assert result == "https://example.com/media/file%2520with%2520space.jpg"
	end

	test "properly applies Guardian image query quirk" do
	clear_config(:test_url_encoding, true)

	url =
	"https://i.guim.co.uk/img/media/1069ef13c447908272c4de94174cec2b6352cb2f/0_91_2000_1201/master/2000.jpg?width=1200&height=630&quality=85&auto=format&fit=crop&precrop=40:21,offset-x50,offset-y0&overlay-align=bottom%2Cleft&overlay-width=100p&overlay-base64=L2ltZy9zdGF0aWMvb3ZlcmxheXMvdGctb3BpbmlvbnMtYWdlLTIwMTkucG5n&enable=upscale&s=cba21427a73512fdc9863c486c03fdd8"

	result = URIEncoding.encode_url(url)

	assert result == url

	{:ok, result_get} = HTTP.get(result)

	assert result_get.status == 200
	end

	test "properly encodes spaces as \"pluses\" in query when using quirks" do
	clear_config(:test_url_encoding, true)

	url =
	"https://i.guim.co.uk/emoji/Pack 1/koronebless.png?precrop=40:21,overlay-x0,overlay-y0&foo=bar baz"

	properly_encoded_url =
	"https://i.guim.co.uk/emoji/Pack%201/koronebless.png?precrop=40:21,overlay-x0,overlay-y0&foo=bar+baz"

	result = URIEncoding.encode_url(url)

	assert result == properly_encoded_url

	{:ok, result_get} = HTTP.get(result)

	assert result_get.status == 200
	end

	test "properly encode AWS S3 queries" do
	clear_config(:test_url_encoding, true)

	url =
	"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=accessKEY%2F20130721%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20130721T201207Z&X-Amz-Expires=86400&X-Amz-Signature=SIGNATURE&X-Amz-SignedHeaders=host"

	unencoded_url =
	"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=accessKEY/20130721/us-east-1/s3/aws4_request&X-Amz-Date=20130721T201207Z&X-Amz-Expires=86400&X-Amz-Signature=SIGNATURE&X-Amz-SignedHeaders=host"

	result = URIEncoding.encode_url(url)
	result_unencoded = URIEncoding.encode_url(unencoded_url)

	assert result == url
	assert result == result_unencoded

	{:ok, result_get} = HTTP.get(result)

	assert result_get.status == 200
	end

	test "preserves query key order" do
	clear_config(:test_url_encoding, true)

	url = "https://example.com/foo?hjkl=qwertz&xyz=abc&bar=baz"

	result = URIEncoding.encode_url(url)

	assert result == url
	end
	end
	diff --git a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	index 99522994a..c15967eee 100644
	--- a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	+++ b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	@@ -1,71 +1,71 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo.Migrations.AutolinkerToLinkifyTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	import Pleroma.Factory
	import Pleroma.Tests.Helpers
	alias Pleroma.ConfigDB

	setup_all do: require_migration("20200716195806_autolinker_to_linkify")

	test "change/0 converts auto_linker opts for Pleroma.Formatter", %{migration: migration} do
	autolinker_opts = [
	extra: true,
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "testing"
	]

	insert(:config, group: :auto_linker, key: :opts, value: autolinker_opts)

	migration.change()

	assert nil == ConfigDB.get_by_params(%{group: :auto_linker, key: :opts})

	%{value: new_opts} = ConfigDB.get_by_params(%{group: :pleroma, key: Pleroma.Formatter})

	assert Keyword.equal?(new_opts,
	class: false,
	extra: true,
	new_window: false,
	rel: "testing",
	strip_prefix: false
	)

	clear_config(Pleroma.Formatter, new_opts)
	assert new_opts == Pleroma.Config.get(Pleroma.Formatter)

	{text, _mentions, []} =
	Pleroma.Formatter.linkify(
	"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\n\nOmg will COVID finally end Black Friday???"
	)

	assert text ==
	"<a href=\"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\" rel=\"testing\">https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7</a>\n\nOmg will COVID finally end Black Friday???"
	end

	test "transform_opts/1 returns a list of compatible opts", %{migration: migration} do
	old_opts = [
	extra: true,
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "qqq"
	]

	expected_opts = [
	class: false,
	extra: true,
	new_window: false,
	rel: "qqq",
	strip_prefix: false
	]

	assert Keyword.equal?(migration.transform_opts(old_opts), expected_opts)
	end
	end
	diff --git a/test/pleroma/upload/filter/exiftool/strip_location_test.exs b/test/pleroma/upload/filter/exiftool/strip_location_test.exs
	index 4dcd4dce3..485060215 100644
	--- a/test/pleroma/upload/filter/exiftool/strip_location_test.exs
	+++ b/test/pleroma/upload/filter/exiftool/strip_location_test.exs
	@@ -1,51 +1,51 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.Exiftool.StripLocationTest do
	use Pleroma.DataCase, async: true
	alias Pleroma.Upload.Filter

	test "apply exiftool filter" do
	assert Pleroma.Utils.command_available?("exiftool")

	~w{jpg png}
	\|> Enum.map(fn type ->
	File.cp!(
	"test/fixtures/DSCN0010.#{type}",
	"test/fixtures/DSCN0010_tmp.#{type}"
	)

	upload = %Pleroma.Upload{
	name: "image_with_GPS_data.#{type}",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/DSCN0010.#{type}"),
	tempfile: Path.absname("test/fixtures/DSCN0010_tmp.#{type}")
	}

	assert Filter.Exiftool.StripLocation.filter(upload) == {:ok, :filtered}

	- {exif_original, 0} = System.cmd("exiftool", ["test/fixtures/DSCN0010.#{type}"])
	- {exif_filtered, 0} = System.cmd("exiftool", ["test/fixtures/DSCN0010_tmp.#{type}"])
	+ {exif_original, 0} = System.cmd("exiftool", ["-m", "test/fixtures/DSCN0010.#{type}"])
	+ {exif_filtered, 0} = System.cmd("exiftool", ["-m", "test/fixtures/DSCN0010_tmp.#{type}"])

	assert String.match?(exif_original, ~r/GPS/)
	refute String.match?(exif_filtered, ~r/GPS/)
	end)
	end

	test "verify webp, heic, svg files are skipped" do
	uploads =
	~w{webp heic svg svg+xml}
	\|> Enum.map(fn type ->
	%Pleroma.Upload{
	name: "sample.#{type}",
	content_type: "image/#{type}"
	}
	end)

	uploads
	\|> Enum.each(fn upload ->
	assert Filter.Exiftool.StripLocation.filter(upload) == {:ok, :noop}
	end)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs b/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	index 8d2a6b4fa..270c650e0 100644
	--- a/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	@@ -1,155 +1,155 @@
	defmodule Pleroma.Web.ActivityPub.MRF.RemoteReportPolicyTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy

	setup do
	clear_config([:mrf_remote_report, :reject_all], false)
	end

	test "doesn't impact local report" do
	clear_config([:mrf_remote_report, :reject_anonymous], true)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "http://localhost:4001/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects anonymous report if `reject_anonymous: true`" do
	clear_config([:mrf_remote_report, :reject_anonymous], true)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves anonymous report if `reject_anonymous: false`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects report on third party if `reject_third_party: true`" do
	clear_config([:mrf_remote_report, :reject_third_party], true)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves report on first party if `reject_third_party: true`" do
	clear_config([:mrf_remote_report, :reject_third_party], true)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["http://localhost:4001/actor"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves report on third party if `reject_third_party: false`" do
	clear_config([:mrf_remote_report, :reject_third_party], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects empty message report if `reject_empty_message: true`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects empty message report (\"\") if `reject_empty_message: true`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"],
	"content" => ""
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves empty message report if `reject_empty_message: false`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves anonymous, empty message report with all settings disabled" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "reject remote report if `reject_all: true`" do
	clear_config([:mrf_remote_report, :reject_all], true)
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"content" => "Transphobia",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/utils_test.exs b/test/pleroma/web/activity_pub/utils_test.exs
	index a48639c38..f162f3684 100644
	--- a/test/pleroma/web/activity_pub/utils_test.exs
	+++ b/test/pleroma/web/activity_pub/utils_test.exs
	@@ -1,747 +1,747 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.UtilsTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	describe "strip_report_status_data/1" do
	test "does not break on issues with the reported activities" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"
	post_id = activity.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => post_id}],
	content: content
	},
	%{}
	)

	res =
	res
	\|> Map.put("object", res["object"] ++ [nil, 1, 5, "123"])

	{:ok, activity} = Pleroma.Web.ActivityPub.ActivityPub.insert(res)

	[user_id, object \| _] = activity.data["object"]

	{:ok, stripped} = Utils.strip_report_status_data(activity)

	assert stripped.data["object"] == [user_id, object["id"]]
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object has tags as map" do
	object = %{
	"tag" => %{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not address actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	visibility: "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	describe "make_json_ld_header/1" do
	test "makes jsonld header" do
	assert Utils.make_json_ld_header() == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	test "includes language if specified" do
	assert Utils.make_json_ld_header(%{"language" => "pl"}) == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "pl"
	}
	]
	}
	end
	end

	describe "get_existing_votes" do
	test "fetches existing votes" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How do I pronounce LaTeX?",
	poll: %{
	options: ["laytekh", "lahtekh", "latex"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, votes, object} = CommonAPI.vote(object, other_user, [0, 1])
	assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
	end

	test "fetches only Create activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Are we living in a society?",
	poll: %{
	options: ["yes", "no"],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, [vote], object} = CommonAPI.vote(object, other_user, [0])
	{:ok, _activity} = CommonAPI.favorite(activity.id, user)
	[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
	assert fetched_vote.id == vote.id
	end
	end

	describe "update_follow_state_for_all/2" do
	test "updates the state of all Follow activities with the same actor and object" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(user, follower)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "accept")

	assert refresh_record(follow_activity).data["state"] == "accept"
	assert refresh_record(follow_activity_two).data["state"] == "accept"
	end

	test "also updates the state of accepted follows" do
	user = insert(:user)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(user, follower)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "reject"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(user, follower)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(user, follower)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "pending"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_element_in_object/3" do
	test "updates likes" do
	user = insert(:user)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	assert {:ok, updated_object} =
	Utils.update_element_in_object(
	"like",
	[user.ap_id],
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "add_like_to_object/2" do
	test "add actor to likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note)

	assert {:ok, updated_object} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1

	assert {:ok, updated_object2} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user2.ap_id}},
	updated_object
	)

	assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
	assert updated_object2.data["like_count"] == 2
	end
	end

	describe "remove_like_from_object/2" do
	test "removes ap_id from likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})

	assert {:ok, updated_object} =
	Utils.remove_like_from_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user2.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "get_existing_like/2" do
	test "fetches existing like" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)

	user = insert(:user)
	refute Utils.get_existing_like(user.ap_id, object)
	{:ok, like_activity} = CommonAPI.favorite(note_activity.id, user)

	assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
	end
	end

	describe "get_get_existing_announce/2" do
	test "returns nil if announce not found" do
	actor = insert(:user)
	refute Utils.get_existing_announce(actor.ap_id, %{data: %{"id" => "test"}})
	end

	test "fetches existing announce" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)
	actor = insert(:user)

	{:ok, announce} = CommonAPI.repeat(note_activity.id, actor)
	assert Utils.get_existing_announce(actor.ap_id, object) == announce
	end
	end

	describe "fetch_latest_block/2" do
	test "fetches last block activities" do
	user1 = insert(:user)
	user2 = insert(:user)

	assert {:ok, %Activity{} = _} = CommonAPI.block(user2, user1)
	assert {:ok, %Activity{} = _} = CommonAPI.block(user2, user1)
	assert {:ok, %Activity{} = activity} = CommonAPI.block(user2, user1)

	assert Utils.fetch_latest_block(user1, user2) == activity
	end
	end

	describe "recipient_in_message/3" do
	test "returns true when recipient in `to`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"to" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"to" => [recipient.ap_id], "cc" => ""}
	)
	end

	test "returns true when recipient in `cc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"cc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"cc" => [recipient.ap_id], "to" => ""}
	)
	end

	test "returns true when recipient in `bto`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bto" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bcc" => "", "bto" => [recipient.ap_id]}
	)
	end

	test "returns true when recipient in `bcc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bcc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bto" => "", "bcc" => [recipient.ap_id]}
	)
	end

	test "returns true when message without addresses fields" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bccc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"btod" => "", "bccc" => [recipient.ap_id]}
	)
	end

	test "returns false" do
	recipient = insert(:user)
	actor = insert(:user)
	refute Utils.recipient_in_message(recipient, actor, %{"to" => "ap_id"})
	end
	end

	describe "lazy_put_activity_defaults/2" do
	test "returns map with id and published data" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	res = Utils.lazy_put_activity_defaults(%{"context" => object.data["id"]})
	assert res["context"] == object.data["id"]
	assert res["id"]
	assert res["published"]
	end

	test "returns map with fake id and published data" do
	assert %{
	"context" => "pleroma:fakecontext",
	"id" => "pleroma:fakeid",
	"published" => _
	} = Utils.lazy_put_activity_defaults(%{}, true)
	end

	test "returns activity data with object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)

	res =
	Utils.lazy_put_activity_defaults(%{
	"context" => object.data["id"],
	"object" => %{}
	})

	assert res["context"] == object.data["id"]
	assert res["id"]
	assert res["published"]
	assert res["object"]["id"]
	assert res["object"]["published"]
	assert res["object"]["context"] == object.data["id"]
	end
	end

	describe "make_flag_data" do
	test "returns empty map when params is invalid" do
	assert Utils.make_flag_data(%{}, %{}) == %{}
	end

	test "returns map with Flag object" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	object_ap_id = activity.object.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => activity.data["id"]}],
	content: content
	},
	%{}
	)

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end

	test "returns map with Flag object with a non-Create Activity" do
	reporter = insert(:user)
	posting_account = insert(:user)
	target_account = insert(:user)

	{:ok, activity} = CommonAPI.post(posting_account, %{status: "foobar"})
	{:ok, like} = CommonAPI.favorite(activity.id, target_account)
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	object_ap_id = activity.object.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => like.data["id"]}],
	content: content
	},
	%{}
	)

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: posting_account, skip_visibility_check: true})
	}

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end
	end

	describe "add_announce_to_object/2" do
	test "adds actor to announcement" do
	user = insert(:user)
	object = insert(:note)

	activity =
	insert(:note_activity,
	data: %{
	"actor" => user.ap_id,
	"cc" => [Pleroma.Constants.as_public()]
	}
	)

	assert {:ok, updated_object} = Utils.add_announce_to_object(activity, object)
	assert updated_object.data["announcements"] == [user.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "remove_announce_from_object/2" do
	test "removes actor from announcements" do
	user = insert(:user)
	user2 = insert(:user)

	object =
	insert(:note,
	data: %{"announcements" => [user.ap_id, user2.ap_id], "announcement_count" => 2}
	)

	activity = insert(:note_activity, data: %{"actor" => user.ap_id})

	assert {:ok, updated_object} = Utils.remove_announce_from_object(activity, object)
	assert updated_object.data["announcements"] == [user2.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "get_cached_emoji_reactions/1" do
	test "returns the normalized data or an empty list" do
	object = insert(:note)
	assert Utils.get_cached_emoji_reactions(object) == []

	object = insert(:note, data: %{"reactions" => [["x", ["lain"]]]})
	assert Utils.get_cached_emoji_reactions(object) == [["x", ["lain"], nil]]

	object = insert(:note, data: %{"reactions" => %{}})
	assert Utils.get_cached_emoji_reactions(object) == []
	end
	end

	describe "add_emoji_reaction_to_object/1" do
	test "works with legacy 2-tuple format" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	_activity = insert(:note_activity, user: user, note: note)

	Utils.add_emoji_reaction_to_object(
	%Activity{data: %{"content" => "😿", "actor" => third_user.ap_id}},
	note
	)
	end
	end

	describe "maybe_anonymize_reporter/1" do
	setup do
	reporter = insert(:user)
	report = %{"actor" => reporter.ap_id}

	%{
	placeholder: insert(:user),
	reporter: reporter,
	report: report
	}
	end

	test "anonymize when configured correctly", %{
	placeholder: placeholder,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	assert %{"actor" => placeholder.ap_id} == Utils.maybe_anonymize_reporter(report)
	end

	test "anonymize Activity", %{
	placeholder: placeholder,
	reporter: reporter,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)
	report_activity = %Activity{actor: reporter, data: report}
	anon_id = placeholder.ap_id

	assert %Activity{actor: ^anon_id, data: %{"actor" => ^anon_id}} =
	Utils.maybe_anonymize_reporter(report_activity)
	end

	test "do not anonymize when disabled", %{
	placeholder: placeholder,
	reporter: reporter,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], false)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	assert %{"actor" => reporter.ap_id} == Utils.maybe_anonymize_reporter(report)
	end

	test "do not anonymize when user does not exist", %{
	placeholder: placeholder,
	reporter: reporter,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], true)

	clear_config(
	[:activitypub, :anonymize_reporter_local_nickname],
	placeholder.nickname <> "MewMew"
	)

	assert %{"actor" => reporter.ap_id} == Utils.maybe_anonymize_reporter(report)
	end

	test "do not anonymize when user is not local", %{
	reporter: reporter,
	report: report
	} do
	placeholder = insert(:user, local: false)
	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	assert %{"actor" => reporter.ap_id} == Utils.maybe_anonymize_reporter(report)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/views/user_view_test.exs b/test/pleroma/web/activity_pub/views/user_view_test.exs
	index 7ac5f7c0f..a3f807ca9 100644
	--- a/test/pleroma/web/activity_pub/views/user_view_test.exs
	+++ b/test/pleroma/web/activity_pub/views/user_view_test.exs
	@@ -1,224 +1,224 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.UserViewTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.CommonAPI

	test "Renders a user, including the public key" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["preferredUsername"] == user.nickname

	assert String.contains?(result["publicKey"]["publicKeyPem"], "BEGIN PUBLIC KEY")
	end

	test "Renders profile fields" do
	fields = [
	%{"name" => "foo", "value" => "bar"}
	]

	{:ok, user} =
	insert(:user)
	\|> User.update_changeset(%{fields: fields})
	\|> User.update_and_set_cache()

	assert %{
	"attachment" => [%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"}]
	} = UserView.render("user.json", %{user: user})
	end

	test "Renders with emoji tags" do
	user = insert(:user, emoji: %{"bib" => "/test"})

	assert %{
	"tag" => [
	%{
	"icon" => %{"type" => "Image", "url" => "/test"},
	"id" => "/test",
	"name" => ":bib:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	} = UserView.render("user.json", %{user: user})
	end

	test "Does not add an avatar image if the user hasn't set one" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})
	refute result["icon"]
	refute result["image"]

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	banner: %{"url" => [%{"href" => "https://somebanner"}]}
	)

	result = UserView.render("user.json", %{user: user})
	assert result["icon"]["url"] == "https://someurl"
	assert result["image"]["url"] == "https://somebanner"

	refute result["icon"]["name"]
	refute result["image"]["name"]
	end

	test "Avatar has a description if the user set one" do
	user =
	insert(:user,
	avatar: %{
	"url" => [%{"href" => "https://someurl"}],
	"name" => "a drawing of pleroma-tan using pleroma groups"
	}
	)

	result = UserView.render("user.json", %{user: user})

	assert result["icon"]["name"] == "a drawing of pleroma-tan using pleroma groups"
	end

	test "renders an invisible user with the invisible property set to true" do
	user = insert(:user, invisible: true)

	assert %{"invisible" => true} = UserView.render("service.json", %{user: user})
	end

	test "service has a few essential fields" do
	user = insert(:user)
	result = UserView.render("service.json", %{user: user})
	assert result["id"]
	assert result["type"] == "Application"
	assert result["inbox"]
	assert result["outbox"]
	end

	test "renders AKAs" do
	akas = ["https://i.tusooa.xyz/users/test-pleroma"]
	user = insert(:user, also_known_as: akas)
	assert %{"alsoKnownAs" => ^akas} = UserView.render("user.json", %{user: user})
	end

	test "renders full nickname" do
	clear_config([Pleroma.Web.WebFinger, :domain], "plemora.dev")

	user = insert(:user, nickname: "user")
	assert %{"webfinger" => "acct:user@plemora.dev"} = UserView.render("user.json", %{user: user})
	end

	describe "endpoints" do
	test "local users have a usable endpoints structure" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id

	%{
	"sharedInbox" => _,
	"oauthAuthorizationEndpoint" => _,
	"oauthRegistrationEndpoint" => _,
	"oauthTokenEndpoint" => _
	} = result["endpoints"]
	end

	test "remote users have an empty endpoints structure" do
	user = insert(:user, local: false)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["endpoints"] == %{}
	end

	test "instance users do not expose oAuth endpoints" do
	user = insert(:user, nickname: nil, local: true)

	result = UserView.render("user.json", %{user: user})

	refute result["endpoints"]["oauthAuthorizationEndpoint"]
	refute result["endpoints"]["oauthRegistrationEndpoint"]
	refute result["endpoints"]["oauthTokenEndpoint"]
	end
	end

	describe "followers" do
	test "sets totalItems to zero when followers are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: true, hide_followers: true})
	refute UserView.render("followers.json", %{user: user}) \|> Map.has_key?("totalItems")
	end

	test "sets correct totalItems when followers are hidden but the follower counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: false, hide_followers: true})
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	end

	test "does not hide follower items based on `hide_follows`" do
	user = insert(:user)
	follower = insert(:user)
	{:ok, user, _follower, _activity} = CommonAPI.follow(user, follower)

	user = Map.merge(user, %{hide_followers: false, hide_follows: true})
	follower_ap_id = follower.ap_id

	assert %{"first" => %{"orderedItems" => [^follower_ap_id]}} =
	UserView.render("followers.json", %{user: user})
	end
	end

	describe "following" do
	test "sets totalItems to zero when follows are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: true, hide_follows: true})
	assert %{"totalItems" => 0} = UserView.render("following.json", %{user: user})
	end

	test "sets correct totalItems when follows are hidden but the follow counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: false, hide_follows: true})
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	end
	end

	describe "acceptsChatMessages" do
	test "it returns this value if it is set" do
	true_user = insert(:user, accepts_chat_messages: true)
	false_user = insert(:user, accepts_chat_messages: false)
	nil_user = insert(:user, accepts_chat_messages: nil)

	assert %{"capabilities" => %{"acceptsChatMessages" => true}} =
	UserView.render("user.json", user: true_user)

	assert %{"capabilities" => %{"acceptsChatMessages" => false}} =
	UserView.render("user.json", user: false_user)

	refute Map.has_key?(
	UserView.render("user.json", user: nil_user)["capabilities"],
	"acceptsChatMessages"
	)
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	index c78c03aba..8c3682798 100644
	--- a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	@@ -1,90 +1,95 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatMessageReferenceViewTest do
	alias Pleroma.NullCache
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView

	import Mox
	import Pleroma.Factory

	+ setup do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+ :ok
	+ end
	+
	setup do: clear_config([:rich_media, :enabled], true)

	test "it displays a chat message" do
	user = insert(:user)
	recipient = insert(:user)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: recipient.ap_id)

	{:ok, activity} =
	CommonAPI.post_chat_message(user, recipient, "kippis :firefox:", idempotency_key: "123")

	chat = Chat.get(user.id, recipient.ap_id)

	object = Object.normalize(activity, fetch: false)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	id = cm_ref.id

	Pleroma.CachexMock
	\|> stub(:get, fn
	:chat_message_id_idempotency_key_cache, ^id -> {:ok, "123"}
	cache, key -> NullCache.get(cache, key)
	end)
	\|> stub(:fetch, fn :rich_media_cache, _, _ -> {:ok, {:ok, %{}}} end)

	chat_message = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message[:id] == cm_ref.id
	assert chat_message[:content] == "kippis :firefox:"
	assert chat_message[:account_id] == user.id
	assert chat_message[:chat_id]
	assert chat_message[:created_at]
	assert chat_message[:unread] == false
	assert match?([%{shortcode: "firefox"}], chat_message[:emojis])
	assert chat_message[:idempotency_key] == "123"

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

	{:ok, activity} =
	CommonAPI.post_chat_message(recipient, user, "gkgkgk https://example.com/ogp",
	media_id: upload.id
	)

	ObanHelpers.perform_all()

	object = Object.normalize(activity, fetch: false)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	chat_message_two = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message_two[:id] == cm_ref.id
	assert chat_message_two[:content] == object.data["content"]
	assert chat_message_two[:account_id] == recipient.id
	assert chat_message_two[:chat_id] == chat_message[:chat_id]
	assert chat_message_two[:attachment]
	assert chat_message_two[:unread] == true
	assert chat_message_two[:card]
	end
	end
	diff --git a/test/pleroma/web/rich_media/card_test.exs b/test/pleroma/web/rich_media/card_test.exs
	index c69f85323..723446c86 100644
	--- a/test/pleroma/web/rich_media/card_test.exs
	+++ b/test/pleroma/web/rich_media/card_test.exs
	@@ -1,105 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.CardTest do
	use Oban.Testing, repo: Pleroma.Repo
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Card
	alias Pleroma.Workers.RichMediaWorker

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

	setup do: clear_config([:rich_media, :enabled], true)

	test "crawls URL in activity" do
	user = insert(:user)

	url = "https://example.com/ogp"
	url_hash = Card.url_to_hash(url)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](#{url})",
	content_type: "text/markdown"
	})

	Pleroma.Web.ActivityPub.ActivityPubMock
	\|> expect(:stream_out, fn ^activity -> nil end)

	assert_enqueued(
	worker: RichMediaWorker,
	args: %{"url" => url, "activity_id" => activity.id}
	)

	ObanHelpers.perform_all()

	assert %Card{url_hash: ^url_hash, fields: _} = Card.get_by_activity(activity)
	end

	test "recrawls URLs on status edits/updates" do
	original_url = "https://google.com/"
	original_url_hash = Card.url_to_hash(original_url)
	updated_url = "https://yahoo.com/"
	updated_url_hash = Card.url_to_hash(updated_url)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "I like this site #{original_url}"})

	# Force a backfill
	Card.get_by_activity(activity)
	ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^original_url_hash, fields: _},
	Card.get_by_activity(activity)
	)

	{:ok, _} = CommonAPI.update(activity, user, %{status: "I like this site #{updated_url}"})

	activity = Pleroma.Activity.get_by_id(activity.id)

	# Force a backfill
	Card.get_by_activity(activity)
	ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^updated_url_hash, fields: _},
	Card.get_by_activity(activity)
	)
	end

	test "refuses to crawl URL in activity from ignored host/domain" do
	clear_config([:rich_media, :ignore_hosts], ["example.com"])

	user = insert(:user)

	url = "https://example.com/ogp"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](#{url})",
	content_type: "text/markdown"
	})

	refute_enqueued(
	worker: RichMediaWorker,
	args: %{"url" => url, "activity_id" => activity.id}
	)
	end
	end
	diff --git a/test/pleroma/web/streamer_test.exs b/test/pleroma/web/streamer_test.exs
	index 096ca2d2a..f5008f6b9 100644
	--- a/test/pleroma/web/streamer_test.exs
	+++ b/test/pleroma/web/streamer_test.exs
	@@ -1,1112 +1,1117 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StreamerTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Conversation.Participation
	alias Pleroma.List
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.StreamerView

	@moduletag needs_streamer: true, capture_log: true

	- setup do: clear_config([:instance, :skip_thread_containment])
	+ setup do
	+ clear_config([:instance, :skip_thread_containment])
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+
	+ :ok
	+ end

	describe "get_topic/_ (unauthenticated)" do
	test "allows no stream" do
	assert {:ok, nil} = Streamer.get_topic(nil, nil, nil)
	end

	test "allows public" do
	assert {:ok, "public"} = Streamer.get_topic("public", nil, nil)
	assert {:ok, "public:local"} = Streamer.get_topic("public:local", nil, nil)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", nil, nil)
	assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", nil, nil)
	end

	test "rejects local public streams if restricted_unauthenticated is on" do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)

	assert {:error, :unauthorized} = Streamer.get_topic("public:local", nil, nil)
	assert {:error, :unauthorized} = Streamer.get_topic("public:local:media", nil, nil)
	end

	test "rejects remote public streams if restricted_unauthenticated is on" do
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	assert {:error, :unauthorized} = Streamer.get_topic("public", nil, nil)
	assert {:error, :unauthorized} = Streamer.get_topic("public:media", nil, nil)

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
	end

	test "allows instance streams" do
	assert {:ok, "public:remote:lain.com"} =
	Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})

	assert {:ok, "public:remote:media:lain.com"} =
	Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
	end

	test "allows hashtag streams" do
	assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", nil, nil, %{"tag" => "cofe"})
	end

	test "disallows user streams" do
	assert {:error, _} = Streamer.get_topic("user", nil, nil)
	assert {:error, _} = Streamer.get_topic("user:notification", nil, nil)
	assert {:error, _} = Streamer.get_topic("direct", nil, nil)
	end

	test "disallows list streams" do
	assert {:error, _} = Streamer.get_topic("list", nil, nil, %{"list" => 42})
	end
	end

	describe "get_topic/_ (authenticated)" do
	setup do: oauth_access(["read"])

	test "allows public streams (regardless of OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	with oauth_token <- [nil, read_oauth_token] do
	assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
	assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)

	assert {:ok, "public:local:media"} =
	Streamer.get_topic("public:local:media", user, oauth_token)
	end
	end

	test "allows local public streams if restricted_unauthenticated is on", %{
	user: user,
	token: oauth_token
	} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)

	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)

	assert {:ok, "public:local:media"} =
	Streamer.get_topic("public:local:media", user, oauth_token)

	for token <- [read_notifications_token, badly_scoped_token] do
	assert {:error, :unauthorized} = Streamer.get_topic("public:local", user, token)

	assert {:error, :unauthorized} = Streamer.get_topic("public:local:media", user, token)
	end
	end

	test "allows remote public streams if restricted_unauthenticated is on", %{
	user: user,
	token: oauth_token
	} do
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)

	assert {:ok, "public:remote:lain.com"} =
	Streamer.get_topic("public:remote", user, oauth_token, %{"instance" => "lain.com"})

	assert {:ok, "public:remote:media:lain.com"} =
	Streamer.get_topic("public:remote:media", user, oauth_token, %{
	"instance" => "lain.com"
	})

	for token <- [read_notifications_token, badly_scoped_token] do
	assert {:error, :unauthorized} = Streamer.get_topic("public", user, token)
	assert {:error, :unauthorized} = Streamer.get_topic("public:media", user, token)

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote", user, token, %{
	"instance" => "lain.com"
	})

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote:media", user, token, %{
	"instance" => "lain.com"
	})
	end
	end

	test "allows user streams (with proper OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: read_statuses_token} = oauth_access(["read:statuses"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	expected_user_topic = "user:#{user.id}"
	expected_notification_topic = "user:notification:#{user.id}"
	expected_direct_topic = "direct:#{user.id}"
	expected_pleroma_chat_topic = "user:pleroma_chat:#{user.id}"

	for valid_user_token <- [read_oauth_token, read_statuses_token] do
	assert {:ok, ^expected_user_topic} = Streamer.get_topic("user", user, valid_user_token)

	assert {:ok, ^expected_direct_topic} =
	Streamer.get_topic("direct", user, valid_user_token)

	assert {:ok, ^expected_pleroma_chat_topic} =
	Streamer.get_topic("user:pleroma_chat", user, valid_user_token)
	end

	for invalid_user_token <- [read_notifications_token, badly_scoped_token],
	user_topic <- ["user", "direct", "user:pleroma_chat"] do
	assert {:error, :unauthorized} = Streamer.get_topic(user_topic, user, invalid_user_token)
	end

	for valid_notification_token <- [read_oauth_token, read_notifications_token] do
	assert {:ok, ^expected_notification_topic} =
	Streamer.get_topic("user:notification", user, valid_notification_token)
	end

	for invalid_notification_token <- [read_statuses_token, badly_scoped_token] do
	assert {:error, :unauthorized} =
	Streamer.get_topic("user:notification", user, invalid_notification_token)
	end
	end

	test "allows hashtag streams (regardless of OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	for oauth_token <- [nil, read_oauth_token] do
	assert {:ok, "hashtag:cofe"} =
	Streamer.get_topic("hashtag", user, oauth_token, %{"tag" => "cofe"})
	end
	end

	test "disallows registering to another user's stream", %{user: user, token: read_oauth_token} do
	another_user = insert(:user)
	assert {:error, _} = Streamer.get_topic("user:#{another_user.id}", user, read_oauth_token)

	assert {:error, _} =
	Streamer.get_topic("user:notification:#{another_user.id}", user, read_oauth_token)

	assert {:error, _} = Streamer.get_topic("direct:#{another_user.id}", user, read_oauth_token)
	end

	test "allows list stream that are owned by the user (with `read` or `read:lists` scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	%{token: read_lists_token} = oauth_access(["read:lists"], user: user)
	%{token: invalid_token} = oauth_access(["irrelevant:scope"], user: user)
	{:ok, list} = List.create("Test", user)

	assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, read_oauth_token)

	for valid_token <- [read_oauth_token, read_lists_token] do
	assert {:ok, _} = Streamer.get_topic("list", user, valid_token, %{"list" => list.id})
	end

	assert {:error, _} = Streamer.get_topic("list", user, invalid_token, %{"list" => list.id})
	end

	test "disallows list stream that are not owned by the user", %{user: user, token: oauth_token} do
	another_user = insert(:user)
	{:ok, list} = List.create("Test", another_user)

	assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, oauth_token)
	assert {:error, _} = Streamer.get_topic("list", user, oauth_token, %{"list" => list.id})
	end
	end

	describe "user streams" do
	setup do
	%{user: user, token: token} = oauth_access(["read"])
	notify = insert(:notification, user: user, activity: build(:note_activity))
	{:ok, %{user: user, notify: notify, token: token}}
	end

	test "it streams the user's post in the 'user' stream", %{user: user, token: oauth_token} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it streams boosts of the user in the 'user' stream", %{user: user, token: oauth_token} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, user)

	assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce, _}
	refute Streamer.filtered_by_user?(user, announce)
	end

	test "it does not stream announces of the user's own posts in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, other_user)

	assert Streamer.filtered_by_user?(user, announce)
	end

	test "it does stream notifications announces of the user's own posts in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, other_user)

	notification =
	Pleroma.Notification
	\|> Repo.get_by(%{user_id: user.id, activity_id: announce.id})
	\|> Repo.preload(:activity)

	refute Streamer.filtered_by_user?(user, notification)
	end

	test "it streams boosts of mastodon user in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

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

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

	{:ok, %Pleroma.Activity{data: _data, local: false} = announce} =
	Pleroma.Web.ActivityPub.Transmogrifier.handle_incoming(data)

	assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce, _}
	refute Streamer.filtered_by_user?(user, announce)
	end

	test "it sends notify to in the 'user' stream", %{
	user: user,
	token: oauth_token,
	notify: notify
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	Streamer.stream("user", notify)

	assert_receive {:render_with_user, _, _, ^notify, _}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it sends notify to in the 'user:notification' stream", %{
	user: user,
	token: oauth_token,
	notify: notify
	} do
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	Streamer.stream("user:notification", notify)

	assert_receive {:render_with_user, _, _, ^notify, _}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it sends chat messages to the 'user:pleroma_chat' stream", %{
	user: user,
	token: oauth_token
	} do
	other_user = insert(:user)

	{:ok, create_activity} =
	CommonAPI.post_chat_message(other_user, user, "hey cirno", idempotency_key: "123")

	object = Object.normalize(create_activity, fetch: false)
	chat = Chat.get(user.id, other_user.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	cm_ref = %{cm_ref \| chat: chat, object: object}

	Streamer.get_topic_and_add_socket("user:pleroma_chat", user, oauth_token)
	Streamer.stream("user:pleroma_chat", {user, cm_ref})

	text =
	StreamerView.render(
	"chat_update.json",
	%{chat_message_reference: cm_ref},
	"user:pleroma_chat:#{user.id}"
	)

	assert text =~ "hey cirno"
	assert_receive {:text, ^text}
	end

	test "it sends chat messages to the 'user' stream", %{user: user, token: oauth_token} do
	other_user = insert(:user)

	{:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey cirno")
	object = Object.normalize(create_activity, fetch: false)
	chat = Chat.get(user.id, other_user.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	cm_ref = %{cm_ref \| chat: chat, object: object}

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	Streamer.stream("user", {user, cm_ref})

	text =
	StreamerView.render(
	"chat_update.json",
	%{chat_message_reference: cm_ref},
	"user:#{user.id}"
	)

	assert text =~ "hey cirno"
	assert_receive {:text, ^text}
	end

	test "it sends chat message notifications to the 'user:notification' stream", %{
	user: user,
	token: oauth_token
	} do
	other_user = insert(:user)

	{:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey")

	notify =
	Repo.get_by(Pleroma.Notification, user_id: user.id, activity_id: create_activity.id)
	\|> Repo.preload(:activity)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	Streamer.stream("user:notification", notify)

	assert_receive {:render_with_user, _, _, ^notify, _}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
	user: user,
	token: oauth_token
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, activity} = CommonAPI.post(user, %{status: ":("})
	{:ok, _} = CommonAPI.favorite(activity.id, blocked)

	refute_receive _
	end

	test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(activity, user)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	refute_receive _
	assert Streamer.filtered_by_user?(user, favorite_activity)
	end

	test "it sends favorite to 'user:notification' stream'", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert notif.activity.id == favorite_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end

	test "it doesn't send the 'user:notification' stream' when a domain is blocked", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	{:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	refute_receive _
	assert Streamer.filtered_by_user?(user, favorite_activity)
	end

	test "it sends follow activities to the 'user:notification' stream", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert notif.activity.id == follow_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end

	test "it sends follow relationships updates to the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	user_id = user.id
	other_user = insert(:user)
	other_user_id = other_user.id

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, _follower, _followed, _follow_activity} = CommonAPI.follow(other_user, user)

	assert_receive {:text, event}

	assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
	Jason.decode!(event)

	assert %{
	"follower" => %{
	"follower_count" => 0,
	"following_count" => 0,
	"id" => ^user_id
	},
	"following" => %{
	"follower_count" => 0,
	"following_count" => 0,
	"id" => ^other_user_id
	},
	"state" => "follow_pending"
	} = Jason.decode!(payload)

	assert_receive {:text, event}

	assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
	Jason.decode!(event)

	assert %{
	"follower" => %{
	"follower_count" => 0,
	"following_count" => 1,
	"id" => ^user_id
	},
	"following" => %{
	"follower_count" => 1,
	"following_count" => 0,
	"id" => ^other_user_id
	},
	"state" => "follow_accept"
	} = Jason.decode!(payload)
	end

	test "it streams edits in the 'user' stream", %{user: user, token: oauth_token} do
	sender = insert(:user)
	{:ok, _, _, _} = CommonAPI.follow(sender, user)

	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})
	create = Pleroma.Activity.get_create_by_object_ap_id_with_object(activity.object.data["id"])

	assert_receive {:render_with_user, _, "status_update.json", ^create, _}
	refute Streamer.filtered_by_user?(user, edited)
	end

	test "it streams own edits in the 'user' stream", %{user: user, token: oauth_token} do
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, edited} = CommonAPI.update(activity, user, %{status: "mew mew"})
	create = Pleroma.Activity.get_create_by_object_ap_id_with_object(activity.object.data["id"])

	assert_receive {:render_with_user, _, "status_update.json", ^create, _}
	refute Streamer.filtered_by_user?(user, edited)
	end

	test "it streams posts containing followed hashtags on the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	hashtag = insert(:hashtag, %{name: "tenshi"})
	other_user = insert(:user)
	{:ok, user} = User.follow_hashtag(user, hashtag)

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey #tenshi"})

	assert_receive {:render_with_user, _, "update.json", ^activity, _}
	end

	test "should not stream private posts containing followed hashtags on the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	hashtag = insert(:hashtag, %{name: "tenshi"})
	other_user = insert(:user)
	{:ok, user} = User.follow_hashtag(user, hashtag)

	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	{:ok, activity} =
	CommonAPI.post(other_user, %{status: "hey #tenshi", visibility: "private"})

	refute_receive {:render_with_user, _, "update.json", ^activity, _}
	end
	end

	describe "public streams" do
	test "it sends to public (authenticated)" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(other_user, activity)
	end

	test "it sends to public (unauthenticated)" do
	user = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)

	{:ok, activity} = CommonAPI.post(user, %{status: "Test"})
	activity_id = activity.id
	assert_receive {:text, event}
	assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)

	{:ok, _} = CommonAPI.delete(activity.id, user)
	assert_receive {:text, event}
	assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
	end

	test "handles deletions" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})

	Streamer.get_topic_and_add_socket("public", user, oauth_token)

	{:ok, _} = CommonAPI.delete(activity.id, other_user)
	activity_id = activity.id
	assert_receive {:text, event}
	assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
	end

	test "it streams edits in the 'public' stream" do
	sender = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)
	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})
	assert_receive {:text, _}

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])

	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)
	end

	test "it streams multiple edits in the 'public' stream correctly" do
	sender = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)
	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})
	assert_receive {:text, _}

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])

	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew 2"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])
	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id, "content" => "mew mew 2"} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)
	end
	end

	describe "thread_containment/2" do
	test "it filters to user if recipients invalid and thread containment is enabled" do
	clear_config([:instance, :skip_thread_containment], false)
	author = insert(:user)
	%{user: user, token: oauth_token} = oauth_access(["read"])
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)
	assert_receive {:render_with_user, _, _, ^activity, _}
	assert Streamer.filtered_by_user?(user, activity)
	end

	test "it sends message if recipients invalid and thread containment is disabled" do
	clear_config([:instance, :skip_thread_containment], true)
	author = insert(:user)
	%{user: user, token: oauth_token} = oauth_access(["read"])
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
	clear_config([:instance, :skip_thread_containment], false)
	author = insert(:user)
	user = insert(:user, skip_thread_containment: true)
	%{token: oauth_token} = oauth_access(["read"], user: user)
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user, activity)
	end
	end

	describe "blocks" do
	setup do: oauth_access(["read"])

	test "it filters messages involving blocked users", %{user: user, token: oauth_token} do
	blocked_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked_user)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	{:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
	assert_receive {:render_with_user, _, _, ^activity, _}
	assert Streamer.filtered_by_user?(user, activity)
	end

	test "it filters messages transitively involving blocked users", %{
	user: blocker,
	token: blocker_token
	} do
	blockee = insert(:user)
	friend = insert(:user)

	Streamer.get_topic_and_add_socket("public", blocker, blocker_token)

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

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

	assert_receive {:render_with_user, _, _, ^activity_one, _}
	assert Streamer.filtered_by_user?(blocker, activity_one)

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_two, _}
	assert Streamer.filtered_by_user?(blocker, activity_two)

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

	assert_receive {:render_with_user, _, _, ^activity_three, _}
	assert Streamer.filtered_by_user?(blocker, activity_three)
	end
	end

	describe "lists" do
	setup do: oauth_access(["read"])

	test "it doesn't send unwanted DMs to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)
	user_c = insert(:user)

	{:ok, user_a, user_b} = User.follow(user_a, user_b)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, _activity} =
	CommonAPI.post(user_b, %{
	status: "@#{user_c.nickname} Test",
	visibility: "direct"
	})

	refute_receive _
	end

	test "it doesn't send unwanted private posts to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, _activity} =
	CommonAPI.post(user_b, %{
	status: "Test",
	visibility: "private"
	})

	refute_receive _
	end

	test "it sends wanted private posts to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)

	{:ok, user_a, user_b} = User.follow(user_a, user_b)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, activity} =
	CommonAPI.post(user_b, %{
	status: "Test",
	visibility: "private"
	})

	assert_receive {:render_with_user, _, _, ^activity, _}
	refute Streamer.filtered_by_user?(user_a, activity)
	end
	end

	describe "muted reblogs" do
	setup do: oauth_access(["read"])

	test "it filters muted reblogs", %{user: user1, token: user1_token} do
	user2 = insert(:user)
	user3 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})

	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, announce_activity} = CommonAPI.repeat(create_activity.id, user2)
	assert_receive {:render_with_user, _, _, ^announce_activity, _}
	assert Streamer.filtered_by_user?(user1, announce_activity)
	end

	test "it filters reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, _announce_activity} = CommonAPI.repeat(create_activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert Streamer.filtered_by_user?(user1, notif)
	end

	test "it sends non-reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, _favorite_activity} = CommonAPI.favorite(create_activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	refute Streamer.filtered_by_user?(user1, notif)
	end
	end

	describe "muted threads" do
	test "it filters posts from muted threads" do
	user = insert(:user)
	%{user: user2, token: user2_token} = oauth_access(["read"])
	Streamer.get_topic_and_add_socket("user", user2, user2_token)

	{:ok, user2, user, _activity} = CommonAPI.follow(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(activity, user2)

	assert_receive {:render_with_user, _, _, ^activity, _}
	assert Streamer.filtered_by_user?(user2, activity)
	end
	end

	describe "direct streams" do
	setup do: oauth_access(["read"])

	test "it sends conversation update to the 'direct' stream", %{user: user, token: oauth_token} do
	another_user = insert(:user)

	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

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

	assert_receive {:text, received_event}

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	[participation] = Participation.for_user(user)
	assert last_status["pleroma"]["direct_conversation_id"] == participation.id
	end

	test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted",
	%{user: user, token: oauth_token} do
	another_user = insert(:user)

	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

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

	create_activity_id = create_activity.id
	assert_receive {:render_with_user, _, _, ^create_activity, _}
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)

	{:ok, _} = CommonAPI.delete(create_activity_id, another_user)

	assert_receive {:text, received_event}

	assert %{"event" => "delete", "payload" => ^create_activity_id} =
	Jason.decode!(received_event)

	refute_receive _
	end

	@tag :erratic
	test "it sends conversation update to the 'direct' stream when a message is deleted", %{
	user: user,
	token: oauth_token
	} do
	another_user = insert(:user)
	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

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

	{:ok, create_activity2} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname} 2",
	in_reply_to_status_id: create_activity.id,
	visibility: "direct"
	})

	assert_receive {:render_with_user, _, _, ^create_activity, _}
	assert_receive {:render_with_user, _, _, ^create_activity2, _}
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)

	{:ok, _} = CommonAPI.delete(create_activity2.id, another_user)

	assert_receive {:text, received_event}
	assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)

	assert_receive {:text, received_event}

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	assert last_status["id"] == to_string(create_activity.id)
	end
	end

	describe "stop streaming if token got revoked" do
	setup do
	child_proc = fn start, finalize ->
	fn ->
	start.()

	receive do
	{StreamerTest, :ready} ->
	assert_receive {:render_with_user, _, "update.json", _, _}

	receive do
	{StreamerTest, :revoked} -> finalize.()
	end
	end
	end
	end

	starter = fn user, token ->
	fn -> Streamer.get_topic_and_add_socket("user", user, token) end
	end

	hit = fn -> assert_receive :close end
	miss = fn -> refute_receive :close end

	send_all = fn tasks, thing -> Enum.each(tasks, &send(&1.pid, thing)) end

	%{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	miss: miss,
	send_all: send_all
	}
	end

	test "do not revoke other tokens", %{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	miss: miss,
	send_all: send_all
	} do
	%{user: user, token: token} = oauth_access(["read"])
	%{token: token2} = oauth_access(["read"], user: user)
	%{user: user2, token: user2_token} = oauth_access(["read"])

	post_user = insert(:user)
	CommonAPI.follow(post_user, user)
	CommonAPI.follow(post_user, user2)

	tasks = [
	Task.async(child_proc.(starter.(user, token), hit)),
	Task.async(child_proc.(starter.(user, token2), miss)),
	Task.async(child_proc.(starter.(user2, user2_token), miss))
	]

	{:ok, _} =
	CommonAPI.post(post_user, %{
	status: "hi"
	})

	send_all.(tasks, {StreamerTest, :ready})

	Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)

	send_all.(tasks, {StreamerTest, :revoked})

	Enum.each(tasks, &Task.await/1)
	end

	test "revoke all streams for this token", %{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	send_all: send_all
	} do
	%{user: user, token: token} = oauth_access(["read"])

	post_user = insert(:user)
	CommonAPI.follow(post_user, user)

	tasks = [
	Task.async(child_proc.(starter.(user, token), hit)),
	Task.async(child_proc.(starter.(user, token), hit))
	]

	{:ok, _} =
	CommonAPI.post(post_user, %{
	status: "hi"
	})

	send_all.(tasks, {StreamerTest, :ready})

	Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)

	send_all.(tasks, {StreamerTest, :revoked})

	Enum.each(tasks, &Task.await/1)
	end
	end
	end
	diff --git a/test/pleroma/web/web_finger_test.exs b/test/pleroma/web/web_finger_test.exs
	index eb03c736e..da10abdd2 100644
	--- a/test/pleroma/web/web_finger_test.exs
	+++ b/test/pleroma/web/web_finger_test.exs
	@@ -1,307 +1,308 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFingerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	alias Pleroma.Web.WebFinger
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "host meta" do
	test "returns a link to the xml lrdd" do
	host_info = WebFinger.host_meta()

	assert String.contains?(host_info, Pleroma.Web.Endpoint.url())
	end
	end

	describe "incoming webfinger request" do
	test "works for fqns" do
	user = insert(:user)

	{:ok, result} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "XML")

	assert is_binary(result)
	end

	test "works for ap_ids" do
	user = insert(:user)

	{:ok, result} = WebFinger.webfinger(user.ap_id, "XML")
	assert is_binary(result)
	end
	end

	test "requires exact match for Endpoint host or WebFinger domain" do
	clear_config([Pleroma.Web.WebFinger, :domain], "pleroma.dev")
	user = insert(:user)

	assert {:error, "Couldn't find user"} ==
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}xxxx", "JSON")

	assert {:error, "Couldn't find user"} ==
	WebFinger.webfinger("#{user.nickname}@pleroma.devxxxx", "JSON")

	assert {:ok, _} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "JSON")

	assert {:ok, _} =
	WebFinger.webfinger("#{user.nickname}@pleroma.dev", "JSON")
	end

	describe "fingering" do
	test "returns error for nonsensical input" do
	assert {:error, _} = WebFinger.finger("bliblablu")
	assert {:error, _} = WebFinger.finger("pleroma.social")
	end

	test "returns error when there is no content-type header" do
	Tesla.Mock.mock(fn
	%{url: "https://social.heldscal.la/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/social.heldscal.la_host_meta")
	}}

	%{
	url:
	"https://social.heldscal.la/.well-known/webfinger?resource=acct:invalid_content@social.heldscal.la"
	} ->
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end)

	user = "invalid_content@social.heldscal.la"
	assert {:error, {:content_type, nil}} = WebFinger.finger(user)
	end

	test "returns error when fails parse xml or json" do
	user = "invalid_content@social.heldscal.la"
	assert {:error, %Jason.DecodeError{}} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI for an ActivityPub user" do
	user = "framasoft@framatube.org"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "it works for AP-only user" do
	user = "kpherox@mstdn.jp"

	{:ok, data} = WebFinger.finger(user)

	assert data["magic_key"] == nil
	assert data["salmon"] == nil

	assert data["topic"] == nil
	assert data["subject"] == "acct:kPherox@mstdn.jp"
	assert data["ap_id"] == "https://mstdn.jp/users/kPherox"
	assert data["subscribe_address"] == "https://mstdn.jp/authorize_interaction?acct={uri}"
	end

	test "it gets the xrd endpoint" do
	{:ok, template} = WebFinger.find_lrdd_template("social.heldscal.la")

	assert template == "https://social.heldscal.la/.well-known/webfinger?resource={uri}"
	end

	test "it gets the xrd endpoint for hubzilla" do
	{:ok, template} = WebFinger.find_lrdd_template("macgirvin.com")

	assert template == "https://macgirvin.com/xrd/?uri={uri}"
	end

	test "it gets the xrd endpoint for statusnet" do
	{:ok, template} = WebFinger.find_lrdd_template("status.alpicola.com")

	assert template == "https://status.alpicola.com/main/xrd?uri={uri}"
	end

	test "it works with idna domains as nickname" do
	nickname = "lain@" <> to_string(:idna.encode("zetsubou.みんな"))

	{:ok, _data} = WebFinger.finger(nickname)
	end

	test "it works with idna domains as link" do
	ap_id = "https://" <> to_string(:idna.encode("zetsubou.みんな")) <> "/users/lain"
	{:ok, _data} = WebFinger.finger(ap_id)
	end

	test "respects json content-type" do
	Tesla.Mock.mock(fn
	%{
	url:
	"https://mastodon.social/.well-known/webfinger?resource=acct:emelie@mastodon.social"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/webfinger_emelie.json"),
	headers: [{"content-type", "application/jrd+json"}]
	}}

	%{url: "https://mastodon.social/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mastodon.social_host_meta")
	}}
	end)

	{:ok, _data} = WebFinger.finger("emelie@mastodon.social")
	end

	test "respects xml content-type" do
	Tesla.Mock.mock(fn
	%{
	url: "https://pawoo.net/.well-known/webfinger?resource=acct:pekorino@pawoo.net"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___pawoo.net_users_pekorino.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}

	%{url: "https://pawoo.net/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/pawoo.net_host_meta")
	}}
	end)

	{:ok, _data} = WebFinger.finger("pekorino@pawoo.net")
	end

	test "refuses to process XML remote entities" do
	Tesla.Mock.mock(fn
	%{
	url: "https://pawoo.net/.well-known/webfinger?resource=acct:pekorino@pawoo.net"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/xml_external_entities.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}

	%{url: "https://pawoo.net/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/pawoo.net_host_meta")
	}}
	end)

	assert :error = WebFinger.finger("pekorino@pawoo.net")
	end

	test "prevents spoofing" do
	Tesla.Mock.mock(fn
	%{
	url: "https://gleasonator.com/.well-known/webfinger?resource=acct:alex@gleasonator.com"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/webfinger_spoof.json"),
	headers: [{"content-type", "application/jrd+json"}]
	}}

	%{url: "https://gleasonator.com/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/gleasonator.com_host_meta")
	}}

	%{url: "https://whitehouse.gov/.well-known/webfinger?resource=acct:trump@whitehouse.gov"} ->
	{:ok, %Tesla.Env{status: 404}}
	end)

	{:error, _data} = WebFinger.finger("alex@gleasonator.com")
	end

	test "prevents forgeries" do
	Tesla.Mock.mock(fn
	%{
	url:
	"https://fba.ryona.agency/.well-known/webfinger?resource=acct:graf@fba.ryona.agency"
	} ->
	fake_webfinger =
	File.read!("test/fixtures/webfinger/graf-imposter-webfinger.json") \|> Jason.decode!()

	Tesla.Mock.json(fake_webfinger)

	%{url: url}
	when url in [
	"https://poa.st/.well-known/webfinger?resource=acct:graf@poa.st",
	"https://fba.ryona.agency/.well-known/host-meta"
	] ->
	{:ok, %Tesla.Env{status: 404}}
	end)

	assert {:error, _} = WebFinger.finger("graf@fba.ryona.agency")
	end

	test "prevents forgeries even when the spoofed subject exists on the target domain" do
	Tesla.Mock.mock(fn
	%{url: url}
	when url in [
	"https://attacker.example/.well-known/host-meta",
	"https://victim.example/.well-known/host-meta"
	] ->
	{:ok, %Tesla.Env{status: 404}}

	%{
	url:
	"https://attacker.example/.well-known/webfinger?resource=acct:alice@attacker.example"
	} ->
	Tesla.Mock.json(%{
	"subject" => "acct:alice@victim.example",
	"links" => [
	%{
	"rel" => "self",
	"type" => "application/activity+json",
	"href" => "https://attacker.example/users/alice"
	}
	]
	})

	%{url: "https://victim.example/.well-known/webfinger?resource=acct:alice@victim.example"} ->
	Tesla.Mock.json(%{
	"subject" => "acct:alice@victim.example",
	"links" => [
	%{
	"rel" => "self",
	"type" => "application/activity+json",
	"href" => "https://victim.example/users/alice"
	}
	]
	})
	end)

	assert {:error, _} = WebFinger.finger("alice@attacker.example")
	end

	test "works for correctly set up split-domain instances implementing host-meta redirect" do
	{:ok, _data} = WebFinger.finger("a@pleroma.example")
	{:ok, _data} = WebFinger.finger("a@sub.pleroma.example")
	end

	test "works for correctly set up split-domain instances without host-meta redirect" do
	{:ok, _data} = WebFinger.finger("a@mastodon.example")
	{:ok, _data} = WebFinger.finger("a@sub.mastodon.example")
	end
	end
	end
	diff --git a/test/pleroma/workers/publisher_worker_test.exs b/test/pleroma/workers/publisher_worker_test.exs
	index ca432d9bf..4519864a5 100644
	--- a/test/pleroma/workers/publisher_worker_test.exs
	+++ b/test/pleroma/workers/publisher_worker_test.exs
	@@ -1,123 +1,123 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.PublisherWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import Mock

	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator

	describe "Oban job priority:" do
	setup do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "Regrettable post"})
	object = Object.normalize(post, fetch: false)
	{:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
	{:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)

	%{
	post: post,
	delete: delete
	}
	end

	test "Deletions are lower priority", %{delete: delete} do
	assert {:ok, %Oban.Job{priority: 3}} = Federator.publish(delete)
	end

	test "Creates are normal priority", %{post: post} do
	assert {:ok, %Oban.Job{priority: 0}} = Federator.publish(post)
	end
	end

	describe "Server reachability:" do
	setup do
	user = insert(:user)
	remote_user = insert(:user, local: false, inbox: "https://example.com/inbox")
	{:ok, _, _} = Pleroma.User.follow(remote_user, user)
	{:ok, activity} = CommonAPI.post(user, %{status: "Test post"})

	%{
	user: user,
	remote_user: remote_user,
	activity: activity
	}
	end

	test "marks server as unreachable only on final failure", %{activity: activity} do
	with_mock Pleroma.Web.Federator,
	perform: fn :publish_one, _params -> {:error, :connection_error} end do
	# First attempt
	job = %Oban.Job{
	args: %{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "https://example.com/inbox",
	"activity_id" => activity.id
	}
	},
	attempt: 1,
	max_attempts: 5
	}

	assert {:error, :connection_error} = Pleroma.Workers.PublisherWorker.perform(job)
	assert Instances.reachable?("https://example.com/inbox")

	# Final attempt
	job = %{job \| attempt: 5}
	assert {:error, :connection_error} = Pleroma.Workers.PublisherWorker.perform(job)
	refute Instances.reachable?("https://example.com/inbox")
	end
	end

	test "does not mark server as unreachable on successful publish", %{activity: activity} do
	with_mock Pleroma.Web.Federator,
	perform: fn :publish_one, _params -> {:ok, %{status: 200}} end do
	job = %Oban.Job{
	args: %{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "https://example.com/inbox",
	"activity_id" => activity.id
	}
	},
	attempt: 1,
	max_attempts: 5
	}

	assert :ok = Pleroma.Workers.PublisherWorker.perform(job)
	assert Instances.reachable?("https://example.com/inbox")
	end
	end

	test "cancels job if server is unreachable", %{activity: activity} do
	# First mark the server as unreachable
	Instances.set_unreachable("https://example.com/inbox")
	refute Instances.reachable?("https://example.com/inbox")

	job = %Oban.Job{
	args: %{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "https://example.com/inbox",
	"activity_id" => activity.id
	}
	},
	attempt: 1,
	max_attempts: 5
	}

	assert {:cancel, :unreachable} = Pleroma.Workers.PublisherWorker.perform(job)
	end
	end
	end
	diff --git a/test/pleroma/workers/reachability_worker_test.exs b/test/pleroma/workers/reachability_worker_test.exs
	index 4854aff77..c641ccf65 100644
	--- a/test/pleroma/workers/reachability_worker_test.exs
	+++ b/test/pleroma/workers/reachability_worker_test.exs
	@@ -1,226 +1,226 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.ReachabilityWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Mock

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Workers.ReachabilityWorker

	setup do
	ObanHelpers.wipe_all()
	:ok
	end

	describe "progressive backoff phases" do
	test "starts with phase_1min and progresses through phases on failure" do
	domain = "example.com"

	with_mocks([
	{Pleroma.HTTP, [], [get: fn _ -> {:error, :timeout} end]},
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	# Start with phase_1min
	job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 1}
	}

	# First attempt fails
	assert {:error, :timeout} = ReachabilityWorker.perform(job)

	# Should schedule retry for phase_1min (attempt 2)
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == "phase_1min"
	assert retry_job.args["attempt"] == 2

	# Clear jobs and simulate second attempt failure
	ObanHelpers.wipe_all()

	retry_job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 2}
	}

	assert {:error, :timeout} = ReachabilityWorker.perform(retry_job)

	# Should schedule retry for phase_1min (attempt 3)
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == "phase_1min"
	assert retry_job.args["attempt"] == 3

	# Clear jobs and simulate third attempt failure (final attempt for phase_1min)
	ObanHelpers.wipe_all()

	retry_job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 3}
	}

	assert {:error, :timeout} = ReachabilityWorker.perform(retry_job)

	# Should schedule retry for phase_1min (attempt 4)
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == "phase_1min"
	assert retry_job.args["attempt"] == 4

	# Clear jobs and simulate fourth attempt failure (final attempt for phase_1min)
	ObanHelpers.wipe_all()

	retry_job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 4}
	}

	assert {:error, :timeout} = ReachabilityWorker.perform(retry_job)

	# Should schedule next phase (phase_15min)
	next_phase_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_phase_jobs) == 1
	[next_phase_job] = next_phase_jobs
	assert next_phase_job.args["phase"] == "phase_15min"
	assert next_phase_job.args["attempt"] == 1
	end
	end

	test "progresses through all phases correctly" do
	domain = "example.com"

	with_mocks([
	{Pleroma.HTTP, [], [get: fn _ -> {:error, :timeout} end]},
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	# Simulate all phases failing
	phases = ["phase_1min", "phase_15min", "phase_1hour", "phase_8hour", "phase_24hour"]

	Enum.each(phases, fn phase ->
	{_interval, max_attempts, next_phase} = get_phase_config(phase)

	# Simulate all attempts failing for this phase
	Enum.each(1..max_attempts, fn attempt ->
	job = %Oban.Job{args: %{"domain" => domain, "phase" => phase, "attempt" => attempt}}
	assert {:error, :timeout} = ReachabilityWorker.perform(job)

	if attempt < max_attempts do
	# Should schedule retry for same phase
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == phase
	assert retry_job.args["attempt"] == attempt + 1
	ObanHelpers.wipe_all()
	else
	# Should schedule next phase (except for final phase)
	if next_phase != "final" do
	next_phase_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_phase_jobs) == 1
	[next_phase_job] = next_phase_jobs
	assert next_phase_job.args["phase"] == next_phase
	assert next_phase_job.args["attempt"] == 1
	ObanHelpers.wipe_all()
	else
	# Final phase - no more jobs should be scheduled
	next_phase_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_phase_jobs) == 0
	end
	end
	end)
	end)
	end
	end

	test "succeeds and stops progression when instance becomes reachable" do
	domain = "example.com"

	with_mocks([
	{Pleroma.HTTP, [], [get: fn _ -> {:ok, %{status: 200}} end]},
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	job = %Oban.Job{args: %{"domain" => domain, "phase" => "phase_1hour", "attempt" => 2}}

	# Should succeed and not schedule any more jobs
	assert :ok = ReachabilityWorker.perform(job)

	# Verify set_reachable was called
	assert_called(Pleroma.Instances.set_reachable("https://#{domain}"))

	# No more jobs should be scheduled
	next_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_jobs) == 0
	end
	end

	test "enforces uniqueness per domain using Oban's conflict detection" do
	domain = "example.com"

	# Insert first job for the domain
	job1 =
	%{
	"domain" => domain,
	"phase" => "phase_1min",
	"attempt" => 1
	}
	\|> ReachabilityWorker.new()
	\|> Oban.insert()

	assert {:ok, _} = job1

	# Try to insert a second job for the same domain with different phase/attempt
	job2 =
	%{
	"domain" => domain,
	"phase" => "phase_15min",
	"attempt" => 1
	}
	\|> ReachabilityWorker.new()
	\|> Oban.insert()

	# Should fail due to uniqueness constraint (conflict)
	assert {:ok, %Oban.Job{conflict?: true}} = job2

	# Verify only one job exists for this domain
	jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(jobs) == 1
	[existing_job] = jobs
	assert existing_job.args["domain"] == domain
	assert existing_job.args["phase"] == "phase_1min"
	end

	test "handles new jobs with only domain argument and transitions them to the first phase" do
	domain = "legacy.example.com"

	with_mocks([
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	# Create a job with only domain (legacy format)
	job = %Oban.Job{
	args: %{"domain" => domain}
	}

	# Should reschedule with phase_1min and attempt 1
	assert :ok = ReachabilityWorker.perform(job)

	# Check that a new job was scheduled with the correct format
	scheduled_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(scheduled_jobs) == 1
	[scheduled_job] = scheduled_jobs
	assert scheduled_job.args["domain"] == domain
	assert scheduled_job.args["phase"] == "phase_1min"
	assert scheduled_job.args["attempt"] == 1
	end
	end
	end

	defp get_phase_config("phase_1min"), do: {1, 4, "phase_15min"}
	defp get_phase_config("phase_15min"), do: {15, 4, "phase_1hour"}
	defp get_phase_config("phase_1hour"), do: {60, 4, "phase_8hour"}
	defp get_phase_config("phase_8hour"), do: {480, 4, "phase_24hour"}
	defp get_phase_config("phase_24hour"), do: {1440, 4, "final"}
	defp get_phase_config("final"), do: {nil, 0, nil}
	end
	diff --git a/test/pleroma/workers/receiver_worker_test.exs b/test/pleroma/workers/receiver_worker_test.exs
	index 7f4789f91..12abc1a27 100644
	--- a/test/pleroma/workers/receiver_worker_test.exs
	+++ b/test/pleroma/workers/receiver_worker_test.exs
	@@ -1,305 +1,305 @@
	# 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: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.ReceiverWorker

	test "it does not retry MRF reject" do
	params = insert(:note).data

	with_mock Pleroma.Web.ActivityPub.Transmogrifier,
	handle_incoming: fn _ -> {:reject, "MRF"} end do
	assert {:cancel, {:reject, "MRF"}} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end

	test "it does not retry ObjectValidator reject" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", Pleroma.Web.ActivityPub.Utils.generate_activity_id())
	\|> Map.put("object", %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id()
	})

	with_mock Pleroma.Web.ActivityPub.ObjectValidator, [:passthrough],
	validate: fn _, _ -> {:error, %Ecto.Changeset{}} end do
	assert {:cancel, {:error, %Ecto.Changeset{}}} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end

	test "it does not retry duplicates" do
	params = insert(:note_activity).data

	assert {:cancel, :already_present} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end

	describe "cancels on a failed user fetch" do
	setup do
	Tesla.Mock.mock(fn
	%{url: "https://springfield.social/users/bart"} ->
	%Tesla.Env{
	status: 403,
	body: ""
	}

	%{url: "https://springfield.social/users/troymcclure"} ->
	%Tesla.Env{
	status: 404,
	body: ""
	}

	%{url: "https://springfield.social/users/hankscorpio"} ->
	%Tesla.Env{
	status: 410,
	body: ""
	}
	end)
	end

	test "when request returns a 403" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/bart")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:error, :forbidden}} = ReceiverWorker.perform(oban_job)
	end

	test "when request returns a 404" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/troymcclure")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:error, :not_found}} = ReceiverWorker.perform(oban_job)
	end

	test "when request returns a 410" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/hankscorpio")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:error, :not_found}} = ReceiverWorker.perform(oban_job)
	end

	test "when user account is disabled" do
	user = insert(:user)

	fake_activity = URI.parse(user.ap_id) \|> Map.put(:path, "/fake-activity") \|> to_string

	params =
	insert(:note_activity, user: user).data
	\|> Map.put("id", fake_activity)

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

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:user_active, false}} = ReceiverWorker.perform(oban_job)
	end
	end

	test "it can validate the signature" do
	Tesla.Mock.mock(fn
	%{url: "https://phpc.social/users/denniskoch"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/denniskoch.json"),
	headers: [{"content-type", "application/activity+json"}]
	}

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

	params =
	File.read!("test/fixtures/receiver_worker_signature_activity.json") \|> Jason.decode!()

	req_headers = [
	["accept-encoding", "gzip"],
	["content-length", "5184"],
	["content-type", "application/activity+json"],
	["date", "Thu, 25 Jul 2024 13:33:31 GMT"],
	["digest", "SHA-256=ouge/6HP2/QryG6F3JNtZ6vzs/hSwMk67xdxe87eH7A="],
	["host", "bikeshed.party"],
	[
	"signature",
	"keyId=\"https://mastodon.social/users/bastianallgeier#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"ymE3vn5Iw50N6ukSp8oIuXJB5SBjGAGjBasdTDvn+ahZIzq2SIJfmVCsIIzyqIROnhWyQoTbavTclVojEqdaeOx+Ejz2wBnRBmhz5oemJLk4RnnCH0lwMWyzeY98YAvxi9Rq57Gojuv/1lBqyGa+rDzynyJpAMyFk17XIZpjMKuTNMCbjMDy76ILHqArykAIL/v1zxkgwxY/+ELzxqMpNqtZ+kQ29znNMUBB3eVZ/mNAHAz6o33Y9VKxM2jw+08vtuIZOusXyiHbRiaj2g5HtN2WBUw1MzzfRfHF2/yy7rcipobeoyk5RvP5SyHV3WrIeZ3iyoNfmv33y8fxllF0EA==\""
	],
	[
	"user-agent",
	"http.rb/5.2.0 (Mastodon/4.3.0-nightly.2024-07-25; +https://mastodon.social/)"
	]
	]

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: req_headers,
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:ok, %Pleroma.Activity{}} = ReceiverWorker.perform(oban_job)
	end

	test "cancels due to origin containment" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", "https://notorigindomain.com/activity")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, :origin_containment_failed} = ReceiverWorker.perform(oban_job)
	end

	test "canceled due to deleted object" do
	params =
	insert(:announce_activity).data
	\|> Map.put("object", "http://localhost:4001/deleted")

	Tesla.Mock.mock(fn
	%{url: "http://localhost:4001/deleted"} ->
	%Tesla.Env{
	status: 404,
	body: ""
	}
	end)

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, _} = ReceiverWorker.perform(oban_job)
	end

	describe "Server reachability:" do
	setup do
	user = insert(:user)
	remote_user = insert(:user, local: false, ap_id: "https://example.com/users/remote")
	{:ok, _, _} = Pleroma.User.follow(user, remote_user)
	{:ok, activity} = CommonAPI.post(remote_user, %{status: "Test post"})

	%{
	user: user,
	remote_user: remote_user,
	activity: activity
	}
	end

	test "schedules ReachabilityWorker if host is unreachable", %{activity: activity} do
	with_mocks [
	{Pleroma.Web.ActivityPub.Transmogrifier, [],
	[handle_incoming: fn _ -> {:ok, activity} end]},
	{Pleroma.Instances, [], [reachable?: fn _ -> false end]},
	{Pleroma.Web.Federator, [], [perform: fn :incoming_ap_doc, _params -> {:ok, nil} end]}
	] do
	job = %Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => activity.data
	}
	}

	Pleroma.Workers.ReceiverWorker.perform(job)

	assert_enqueued(
	worker: Pleroma.Workers.ReachabilityWorker,
	args: %{"domain" => "example.com"}
	)
	end
	end

	test "does not schedule ReachabilityWorker if host is reachable", %{activity: activity} do
	with_mocks [
	{Pleroma.Web.ActivityPub.Transmogrifier, [],
	[handle_incoming: fn _ -> {:ok, activity} end]},
	{Pleroma.Instances, [], [reachable?: fn _ -> true end]},
	{Pleroma.Web.Federator, [], [perform: fn :incoming_ap_doc, _params -> {:ok, nil} end]}
	] do
	job = %Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => activity.data
	}
	}

	Pleroma.Workers.ReceiverWorker.perform(job)

	refute_enqueued(worker: Pleroma.Workers.ReachabilityWorker)
	end
	end
	end
	end
	diff --git a/test/pleroma/workers/remote_fetcher_worker_test.exs b/test/pleroma/workers/remote_fetcher_worker_test.exs
	index 6eb6932cb..a3b900a9b 100644
	--- a/test/pleroma/workers/remote_fetcher_worker_test.exs
	+++ b/test/pleroma/workers/remote_fetcher_worker_test.exs
	@@ -1,84 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.RemoteFetcherWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Workers.RemoteFetcherWorker

	@deleted_object_one "https://deleted-404.example.com/"
	@deleted_object_two "https://deleted-410.example.com/"
	@unauthorized_object "https://unauthorized.example.com/"
	@depth_object "https://depth.example.com/"
	@content_type_object "https://bad_content_type.example.com/"

	describe "RemoteFetcherWorker" do
	setup do
	Tesla.Mock.mock(fn
	%{method: :get, url: @deleted_object_one} ->
	%Tesla.Env{
	status: 404
	}

	%{method: :get, url: @deleted_object_two} ->
	%Tesla.Env{
	status: 410
	}

	%{method: :get, url: @unauthorized_object} ->
	%Tesla.Env{
	status: 403
	}

	%{method: :get, url: @depth_object} ->
	%Tesla.Env{
	status: 200
	}

	%{method: :get, url: @content_type_object} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/spoofed-object.json")
	}
	end)
	end

	test "does not retry jobs for a deleted object" do
	[
	%{"op" => "fetch_remote", "id" => @deleted_object_one},
	%{"op" => "fetch_remote", "id" => @deleted_object_two}
	]
	\|> Enum.each(fn job -> assert {:cancel, _} = perform_job(RemoteFetcherWorker, job) end)
	end

	test "does not retry jobs for an unauthorized object" do
	assert {:cancel, _} =
	perform_job(RemoteFetcherWorker, %{
	"op" => "fetch_remote",
	"id" => @unauthorized_object
	})
	end

	test "does not retry jobs for an an object that exceeded depth" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	assert {:cancel, _} =
	perform_job(RemoteFetcherWorker, %{
	"op" => "fetch_remote",
	"id" => @depth_object,
	"depth" => 1
	})
	end

	test "does not retry jobs for when object returns wrong content type" do
	assert {:cancel, _} =
	perform_job(RemoteFetcherWorker, %{
	"op" => "fetch_remote",
	"id" => @content_type_object
	})
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 3:28 AM (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799334
Default Alt Text: (206 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions