No OneTemporary
Actions

Size

521 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/config/test.exs b/config/test.exs
	index 1903ac9ee..0f8b12ffe 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,202 +1,209 @@
	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.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

	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.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
	diff --git a/lib/pleroma/config.ex b/lib/pleroma/config.ex
	index cf1453c9b..1bc371dec 100644
	--- a/lib/pleroma/config.ex
	+++ b/lib/pleroma/config.ex
	@@ -1,106 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config do
	@behaviour Pleroma.Config.Getting
	defmodule Error do
	defexception [:message]
	end

	@impl true
	def get(key), do: get(key, nil)

	@impl true
	def get([key], default), do: get(key, default)

	@impl true
	def get([_ \| _] = path, default) do
	case fetch(path) do
	{:ok, value} -> value
	:error -> default
	end
	end

	@impl true
	def get(key, default) do
	Application.get_env(:pleroma, key, default)
	end

	+ @impl true
	def get!(key) do
	value = get(key, nil)

	if value == nil do
	raise(Error, message: "Missing configuration value: #{inspect(key)}")
	else
	value
	end
	end

	def fetch(key) when is_atom(key), do: fetch([key])

	def fetch([root_key \| keys]) do
	Enum.reduce_while(keys, Application.fetch_env(:pleroma, root_key), fn
	key, {:ok, config} when is_map(config) or is_list(config) ->
	case Access.fetch(config, key) do
	:error ->
	{:halt, :error}

	value ->
	{:cont, value}
	end

	_key, _config ->
	{:halt, :error}
	end)
	end

	def put([key], value), do: put(key, value)

	def put([parent_key \| keys], value) do
	parent =
	Application.get_env(:pleroma, parent_key, [])
	\|> put_in(keys, value)

	Application.put_env(:pleroma, parent_key, parent)
	end

	def put(key, value) do
	Application.put_env(:pleroma, key, value)
	end

	def delete([key]), do: delete(key)

	def delete([parent_key \| keys] = path) do
	with {:ok, _} <- fetch(path) do
	{_, parent} =
	parent_key
	\|> get()
	\|> get_and_update_in(keys, fn _ -> :pop end)

	Application.put_env(:pleroma, parent_key, parent)
	end
	end

	def delete(key) do
	Application.delete_env(:pleroma, key)
	end

	def restrict_unauthenticated_access?(resource, kind) do
	setting = get([:restrict_unauthenticated, resource, kind])

	if setting in [nil, :if_instance_is_private] do
	!get!([:instance, :public])
	else
	setting
	end
	end

	def oauth_consumer_strategies, do: get([:auth, :oauth_consumer_strategies], [])

	def oauth_consumer_enabled?, do: oauth_consumer_strategies() != []

	def feature_enabled?(feature_name) do
	get([:features, feature_name]) not in [nil, false, :disabled, :auto]
	end
	end
	diff --git a/lib/pleroma/config/getting.ex b/lib/pleroma/config/getting.ex
	index ec93fd02a..adf764f89 100644
	--- a/lib/pleroma/config/getting.ex
	+++ b/lib/pleroma/config/getting.ex
	@@ -1,15 +1,18 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.Getting do
	@callback get(any()) :: any()
	@callback get(any(), any()) :: any()
	+ @callback get!(any()) :: any()

	def get(key), do: get(key, nil)
	def get(key, default), do: impl().get(key, default)

	+ def get!(key), do: impl().get!(key)
	+
	def impl do
	Application.get_env(:pleroma, :config_impl, Pleroma.Config)
	end
	end
	diff --git a/lib/pleroma/datetime.ex b/lib/pleroma/datetime.ex
	new file mode 100644
	index 000000000..d79cb848b
	--- /dev/null
	+++ b/lib/pleroma/datetime.ex
	@@ -0,0 +1,3 @@
	+defmodule Pleroma.DateTime do
	+ @callback utc_now() :: NaiveDateTime.t()
	+end
	diff --git a/lib/pleroma/datetime/impl.ex b/lib/pleroma/datetime/impl.ex
	new file mode 100644
	index 000000000..102be047b
	--- /dev/null
	+++ b/lib/pleroma/datetime/impl.ex
	@@ -0,0 +1,6 @@
	+defmodule Pleroma.DateTime.Impl do
	+ @behaviour Pleroma.DateTime
	+
	+ @impl true
	+ def utc_now, do: NaiveDateTime.utc_now()
	+end
	diff --git a/lib/pleroma/mogrify.ex b/lib/pleroma/mogrify.ex
	new file mode 100644
	index 000000000..77725e8f2
	--- /dev/null
	+++ b/lib/pleroma/mogrify.ex
	@@ -0,0 +1,42 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.MogrifyBehaviour do
	+ @moduledoc """
	+ Behaviour for Mogrify operations.
	+ This module defines the interface for Mogrify operations that can be mocked in tests.
	+ """
	+
	+ @callback open(binary()) :: map()
	+ @callback custom(map(), binary()) :: map()
	+ @callback custom(map(), binary(), binary()) :: map()
	+ @callback save(map(), keyword()) :: map()
	+end
	+
	+defmodule Pleroma.MogrifyWrapper do
	+ @moduledoc """
	+ Default implementation of MogrifyBehaviour that delegates to Mogrify.
	+ """
	+ @behaviour Pleroma.MogrifyBehaviour
	+
	+ @impl true
	+ def open(file) do
	+ Mogrify.open(file)
	+ end
	+
	+ @impl true
	+ def custom(image, action) do
	+ Mogrify.custom(image, action)
	+ end
	+
	+ @impl true
	+ def custom(image, action, options) do
	+ Mogrify.custom(image, action, options)
	+ end
	+
	+ @impl true
	+ def save(image, opts) do
	+ Mogrify.save(image, opts)
	+ end
	+end
	diff --git a/lib/pleroma/upload/filter/anonymize_filename.ex b/lib/pleroma/upload/filter/anonymize_filename.ex
	index 234ccb6bb..c0ad70368 100644
	--- a/lib/pleroma/upload/filter/anonymize_filename.ex
	+++ b/lib/pleroma/upload/filter/anonymize_filename.ex
	@@ -1,38 +1,38 @@
	# 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.AnonymizeFilename do
	@moduledoc """
	Replaces the original filename with a pre-defined text or randomly generated string.

	Should be used after `Pleroma.Upload.Filter.Dedupe`.
	"""
	@behaviour Pleroma.Upload.Filter

	- alias Pleroma.Config
	+ @config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)
	alias Pleroma.Upload

	def filter(%Upload{name: name} = upload) do
	extension = List.last(String.split(name, "."))
	name = predefined_name(extension) \|\| random(extension)
	{:ok, :filtered, %Upload{upload \| name: name}}
	end

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

	@spec predefined_name(String.t()) :: String.t() \| nil
	defp predefined_name(extension) do
	- with name when not is_nil(name) <- Config.get([__MODULE__, :text]),
	+ with name when not is_nil(name) <- @config_impl.get([__MODULE__, :text]),
	do: String.replace(name, "{extension}", extension)
	end

	defp random(extension) do
	string =
	10
	\|> :crypto.strong_rand_bytes()
	\|> Base.url_encode64(padding: false)

	string <> "." <> extension
	end
	end
	diff --git a/lib/pleroma/upload/filter/mogrify.ex b/lib/pleroma/upload/filter/mogrify.ex
	index d1e166022..7c7431db6 100644
	--- a/lib/pleroma/upload/filter/mogrify.ex
	+++ b/lib/pleroma/upload/filter/mogrify.ex
	@@ -1,47 +1,54 @@
	# 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.Mogrify do
	@behaviour Pleroma.Upload.Filter

	@type conversion :: action :: String.t() \| {action :: String.t(), opts :: String.t()}
	@type conversions :: conversion() \| [conversion()]

	+ @config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)
	+ @mogrify_impl Application.compile_env(
	+ :pleroma,
	+ [__MODULE__, :mogrify_impl],
	+ Pleroma.MogrifyWrapper
	+ )
	+
	def filter(%Pleroma.Upload{tempfile: file, content_type: "image" <> _}) do
	try do
	- do_filter(file, Pleroma.Config.get!([__MODULE__, :args]))
	+ do_filter(file, @config_impl.get!([__MODULE__, :args]))
	{:ok, :filtered}
	rescue
	e in ErlangError ->
	{:error, "#{__MODULE__}: #{inspect(e)}"}
	end
	end

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

	def do_filter(file, filters) do
	file
	- \|> Mogrify.open()
	+ \|> @mogrify_impl.open()
	\|> mogrify_filter(filters)
	- \|> Mogrify.save(in_place: true)
	+ \|> @mogrify_impl.save(in_place: true)
	end

	defp mogrify_filter(mogrify, nil), do: mogrify

	defp mogrify_filter(mogrify, [filter \| rest]) do
	mogrify
	\|> mogrify_filter(filter)
	\|> mogrify_filter(rest)
	end

	defp mogrify_filter(mogrify, []), do: mogrify

	defp mogrify_filter(mogrify, {action, options}) do
	- Mogrify.custom(mogrify, action, options)
	+ @mogrify_impl.custom(mogrify, action, options)
	end

	defp mogrify_filter(mogrify, action) when is_binary(action) do
	- Mogrify.custom(mogrify, action)
	+ @mogrify_impl.custom(mogrify, action)
	end
	end
	diff --git a/lib/pleroma/user_relationship.ex b/lib/pleroma/user_relationship.ex
	index 82fcc1cdd..5b48d321a 100644
	--- a/lib/pleroma/user_relationship.ex
	+++ b/lib/pleroma/user_relationship.ex
	@@ -1,244 +1,250 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserRelationship do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Ecto.Changeset
	alias Pleroma.FollowingRelationship
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship

	@type t :: %__MODULE__{}

	schema "user_relationships" do
	belongs_to(:source, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:target, User, type: FlakeId.Ecto.CompatType)
	field(:relationship_type, Pleroma.UserRelationship.Type)
	field(:expires_at, :utc_datetime)

	timestamps(updated_at: false)
	end

	for relationship_type <- Keyword.keys(Pleroma.UserRelationship.Type.__enum_map__()) do
	# `def create_block/3`, `def create_mute/3`, `def create_reblog_mute/3`,
	# `def create_notification_mute/3`, `def create_inverse_subscription/3`,
	# `def endorsement/3`
	def unquote(:"create_#{relationship_type}")(source, target, expires_at \\ nil),
	do: create(unquote(relationship_type), source, target, expires_at)

	# `def delete_block/2`, `def delete_mute/2`, `def delete_reblog_mute/2`,
	# `def delete_notification_mute/2`, `def delete_inverse_subscription/2`,
	# `def delete_endorsement/2`
	def unquote(:"delete_#{relationship_type}")(source, target),
	do: delete(unquote(relationship_type), source, target)

	# `def block_exists?/2`, `def mute_exists?/2`, `def reblog_mute_exists?/2`,
	# `def notification_mute_exists?/2`, `def inverse_subscription_exists?/2`,
	# `def inverse_endorsement_exists?/2`
	def unquote(:"#{relationship_type}_exists?")(source, target),
	do: exists?(unquote(relationship_type), source, target)

	# `def get_block_expire_date/2`, `def get_mute_expire_date/2`,
	# `def get_reblog_mute_expire_date/2`, `def get_notification_mute_exists?/2`,
	# `def get_inverse_subscription_expire_date/2`, `def get_inverse_endorsement_expire_date/2`
	def unquote(:"get_#{relationship_type}_expire_date")(source, target),
	do: get_expire_date(unquote(relationship_type), source, target)
	end

	def user_relationship_types, do: Keyword.keys(user_relationship_mappings())

	def user_relationship_mappings, do: Pleroma.UserRelationship.Type.__enum_map__()

	+ def datetime_impl do
	+ Application.get_env(:pleroma, :datetime_impl, Pleroma.DateTime.Impl)
	+ end
	+
	def changeset(%UserRelationship{} = user_relationship, params \\ %{}) do
	user_relationship
	- \|> cast(params, [:relationship_type, :source_id, :target_id, :expires_at])
	+ \|> cast(params, [:relationship_type, :source_id, :target_id, :expires_at, :inserted_at])
	\|> validate_required([:relationship_type, :source_id, :target_id])
	\|> unique_constraint(:relationship_type,
	name: :user_relationships_source_id_relationship_type_target_id_index
	)
	\|> validate_not_self_relationship()
	end

	+ @spec exists?(any(), Pleroma.User.t(), Pleroma.User.t()) :: boolean()
	def exists?(relationship_type, %User{} = source, %User{} = target) do
	UserRelationship
	\|> where(relationship_type: ^relationship_type, source_id: ^source.id, target_id: ^target.id)
	\|> Repo.exists?()
	end

	def get_expire_date(relationship_type, %User{} = source, %User{} = target) do
	%UserRelationship{expires_at: expires_at} =
	UserRelationship
	\|> where(
	relationship_type: ^relationship_type,
	source_id: ^source.id,
	target_id: ^target.id
	)
	\|> Repo.one!()

	expires_at
	end

	def create(relationship_type, %User{} = source, %User{} = target, expires_at \\ nil) do
	%UserRelationship{}
	\|> changeset(%{
	relationship_type: relationship_type,
	source_id: source.id,
	target_id: target.id,
	- expires_at: expires_at
	+ expires_at: expires_at,
	+ inserted_at: datetime_impl().utc_now()
	})
	\|> Repo.insert(
	on_conflict: {:replace_all_except, [:id, :inserted_at]},
	conflict_target: [:source_id, :relationship_type, :target_id],
	returning: true
	)
	end

	def delete(relationship_type, %User{} = source, %User{} = target) do
	attrs = %{relationship_type: relationship_type, source_id: source.id, target_id: target.id}

	case Repo.get_by(UserRelationship, attrs) do
	%UserRelationship{} = existing_record -> Repo.delete(existing_record)
	nil -> {:ok, nil}
	end
	end

	def dictionary(
	source_users,
	target_users,
	source_to_target_rel_types \\ nil,
	target_to_source_rel_types \\ nil
	)

	def dictionary(
	_source_users,
	_target_users,
	[] = _source_to_target_rel_types,
	[] = _target_to_source_rel_types
	) do
	[]
	end

	def dictionary(
	source_users,
	target_users,
	source_to_target_rel_types,
	target_to_source_rel_types
	)
	when is_list(source_users) and is_list(target_users) do
	source_user_ids = User.binary_id(source_users)
	target_user_ids = User.binary_id(target_users)

	get_rel_type_codes = fn rel_type -> user_relationship_mappings()[rel_type] end

	source_to_target_rel_types =
	Enum.map(source_to_target_rel_types \|\| user_relationship_types(), &get_rel_type_codes.(&1))

	target_to_source_rel_types =
	Enum.map(target_to_source_rel_types \|\| user_relationship_types(), &get_rel_type_codes.(&1))

	__MODULE__
	\|> where(
	fragment(
	"(source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?)) OR \
	(source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?))",
	^source_user_ids,
	^target_user_ids,
	^source_to_target_rel_types,
	^target_user_ids,
	^source_user_ids,
	^target_to_source_rel_types
	)
	)
	\|> select([ur], [ur.relationship_type, ur.source_id, ur.target_id])
	\|> Repo.all()
	end

	def exists?(dictionary, rel_type, source, target, func) do
	cond do
	is_nil(source) or is_nil(target) ->
	false

	dictionary ->
	[rel_type, source.id, target.id] in dictionary

	true ->
	func.(source, target)
	end
	end

	@doc ":relationships option for StatusView / AccountView / NotificationView"
	def view_relationships_option(reading_user, actors, opts \\ [])

	def view_relationships_option(nil = _reading_user, _actors, _opts) do
	%{user_relationships: [], following_relationships: []}
	end

	def view_relationships_option(%User{} = reading_user, actors, opts) do
	{source_to_target_rel_types, target_to_source_rel_types} =
	case opts[:subset] do
	:source_mutes ->
	# Used for statuses rendering (FE needs `muted` flag for each status when statuses load)
	{[:mute], []}

	nil ->
	{[:block, :mute, :notification_mute, :reblog_mute], [:block, :inverse_subscription]}

	unknown ->
	raise "Unsupported :subset option value: #{inspect(unknown)}"
	end

	user_relationships =
	UserRelationship.dictionary(
	[reading_user],
	actors,
	source_to_target_rel_types,
	target_to_source_rel_types
	)

	following_relationships =
	case opts[:subset] do
	:source_mutes ->
	[]

	nil ->
	FollowingRelationship.all_between_user_sets([reading_user], actors)

	unknown ->
	raise "Unsupported :subset option value: #{inspect(unknown)}"
	end

	%{user_relationships: user_relationships, following_relationships: following_relationships}
	end

	defp validate_not_self_relationship(%Changeset{} = changeset) do
	changeset
	\|> validate_source_id_target_id_inequality()
	\|> validate_target_id_source_id_inequality()
	end

	defp validate_source_id_target_id_inequality(%Changeset{} = changeset) do
	validate_change(changeset, :source_id, fn _, source_id ->
	if source_id == get_field(changeset, :target_id) do
	[source_id: "can't be equal to target_id"]
	else
	[]
	end
	end)
	end

	defp validate_target_id_source_id_inequality(%Changeset{} = changeset) do
	validate_change(changeset, :target_id, fn _, target_id ->
	if target_id == get_field(changeset, :source_id) do
	[target_id: "can't be equal to source_id"]
	else
	[]
	end
	end)
	end
	end
	diff --git a/test/mix/tasks/pleroma/digest_test.exs b/test/mix/tasks/pleroma/digest_test.exs
	index 08482aadb..0d1804cdb 100644
	--- a/test/mix/tasks/pleroma/digest_test.exs
	+++ b/test/mix/tasks/pleroma/digest_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 Mix.Tasks.Pleroma.DigestTest do
	use Pleroma.DataCase

	import Pleroma.Factory
	import Swoosh.TestAssertions

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI

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

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

	:ok
	end

	setup do: clear_config([Pleroma.Emails.Mailer, :enabled], true)

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

	describe "pleroma.digest test" do
	test "Sends digest to the given user" do
	user1 = insert(:user)
	user2 = insert(:user)

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

	yesterday =
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-60 * 60 * 24,
	:second
	)

	{:ok, yesterday_date} = Timex.format(yesterday, "%F", :strftime)

	:ok = Mix.Tasks.Pleroma.Digest.run(["test", user2.nickname, yesterday_date])

	ObanHelpers.perform_all()

	assert_receive {:mix_shell, :info, [message]}
	assert message =~ "Digest email have been sent"

	assert_email_sent(
	to: {user2.name, user2.email},
	html_body:
	Regex.compile!(
	"here is what you've missed!"
	\|> Phoenix.HTML.html_escape()
	\|> Phoenix.HTML.safe_to_string(),
	"i"
	)
	)
	end
	end
	end
	diff --git a/test/mix/tasks/pleroma/user_test.exs b/test/mix/tasks/pleroma/user_test.exs
	index c9bcf2951..7ce5e92cb 100644
	--- a/test/mix/tasks/pleroma/user_test.exs
	+++ b/test/mix/tasks/pleroma/user_test.exs
	@@ -1,625 +1,625 @@
	# 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.UserTest do
	alias Pleroma.Activity
	alias Pleroma.MFA
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

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

	import ExUnit.CaptureIO
	import Mock
	import Pleroma.Factory

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

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

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

	:ok
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute User.get_cached_by_nickname(unsaved.nickname)
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute Activity.get_by_id(post.id)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	# end)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute user1.is_confirmed
	refute user2.is_confirmed

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

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

	assert user1.is_confirmed
	assert user2.is_confirmed
	end

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

	assert user1.is_confirmed
	assert user2.is_confirmed

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

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

	refute user1.is_confirmed
	refute user2.is_confirmed
	assert admin.is_confirmed
	assert mod.is_confirmed
	end
	end
	end
	diff --git a/test/pleroma/conversation_test.exs b/test/pleroma/conversation_test.exs
	index 809c1951a..02b5de615 100644
	--- a/test/pleroma/conversation_test.exs
	+++ b/test/pleroma/conversation_test.exs
	@@ -1,204 +1,204 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConversationTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Conversation
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

	test "it goes through old direct conversations" do
	user = insert(:user)
	other_user = insert(:user)

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

	Pleroma.Tests.ObanHelpers.perform_all()

	Repo.delete_all(Conversation)
	Repo.delete_all(Conversation.Participation)

	refute Repo.one(Conversation)

	Conversation.bump_for_all_activities()

	assert Repo.one(Conversation)
	[participation, _p2] = Repo.all(Conversation.Participation)

	assert participation.read
	end

	test "it creates a conversation for given ap_id" do
	assert {:ok, %Conversation{} = conversation} =
	Conversation.create_for_ap_id("https://some_ap_id")

	# Inserting again returns the same
	assert {:ok, conversation_two} = Conversation.create_for_ap_id("https://some_ap_id")
	assert conversation_two.id == conversation.id
	end

	test "public posts don't create conversations" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "Hey"})

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

	conversation = Conversation.get_for_ap_id(context)

	refute conversation
	end

	test "it creates or updates a conversation and participations for a given DM" do
	har = insert(:user)
	jafnhar = insert(:user, local: false)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})

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

	conversation =
	Conversation.get_for_ap_id(context)
	\|> Repo.preload(:participations)

	assert conversation

	assert Enum.find(conversation.participations, fn %{user_id: user_id} -> har.id == user_id end)

	assert Enum.find(conversation.participations, fn %{user_id: user_id} ->
	jafnhar.id == user_id
	end)

	{:ok, activity} =
	CommonAPI.post(jafnhar, %{
	status: "Hey @#{har.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

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

	conversation_two =
	Conversation.get_for_ap_id(context)
	\|> Repo.preload(:participations)

	assert conversation_two.id == conversation.id

	assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
	har.id == user_id
	end)

	assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
	jafnhar.id == user_id
	end)

	{:ok, activity} =
	CommonAPI.post(tridi, %{
	status: "Hey @#{har.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

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

	conversation_three =
	Conversation.get_for_ap_id(context)
	\|> Repo.preload([:participations, :users])

	assert conversation_three.id == conversation.id

	assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
	har.id == user_id
	end)

	assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
	jafnhar.id == user_id
	end)

	assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
	tridi.id == user_id
	end)

	assert Enum.find(conversation_three.users, fn %{id: user_id} ->
	har.id == user_id
	end)

	assert Enum.find(conversation_three.users, fn %{id: user_id} ->
	jafnhar.id == user_id
	end)

	assert Enum.find(conversation_three.users, fn %{id: user_id} ->
	tridi.id == user_id
	end)
	end

	test "create_or_bump_for returns the conversation with participations" do
	har = insert(:user)
	jafnhar = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})

	{:ok, conversation} = Conversation.create_or_bump_for(activity)

	assert length(conversation.participations) == 2

	{:ok, activity} =
	CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "public"})

	assert {:error, _} = Conversation.create_or_bump_for(activity)
	end

	test "create_or_bump_for does not normalize objects before checking the activity type" do
	note = insert(:note)
	note_id = note.data["id"]
	Repo.delete(note)
	refute Object.get_by_ap_id(note_id)

	Tesla.Mock.mock(fn env ->
	case env.url do
	^note_id ->
	# TODO: add attributedTo and tag to the note factory
	body =
	note.data
	\|> Map.put("attributedTo", note.data["actor"])
	\|> Map.put("tag", [])
	\|> Jason.encode!()

	%Tesla.Env{status: 200, body: body}
	end
	end)

	undo = %Activity{
	id: "fake",
	data: %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => note.data["actor"],
	"to" => [note.data["actor"]],
	"object" => note_id,
	"type" => "Undo"
	}
	}

	Conversation.create_or_bump_for(undo)

	refute Object.get_by_ap_id(note_id)
	end
	end
	diff --git a/test/pleroma/emoji/pack_test.exs b/test/pleroma/emoji/pack_test.exs
	index 0c5ee3416..6ab3e657e 100644
	--- a/test/pleroma/emoji/pack_test.exs
	+++ b/test/pleroma/emoji/pack_test.exs
	@@ -1,155 +1,155 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.PackTest do
	use Pleroma.DataCase
	alias Pleroma.Emoji
	alias Pleroma.Emoji.Pack

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	setup do
	pack_path = Path.join(@emoji_path, "dump_pack")
	File.mkdir(pack_path)

	File.write!(Path.join(pack_path, "pack.json"), """
	{
	"files": { },
	"pack": {
	"description": "Dump pack", "homepage": "https://pleroma.social",
	"license": "Test license", "share-files": true
	}}
	""")

	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("dump_pack")

	on_exit(fn ->
	File.rm_rf!(pack_path)
	end)

	{:ok, pack: pack}
	end

	describe "add_file/4" do
	test "add emojies from zip file", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)

	assert updated_pack.files == %{
	"a_trusted_friend-128" => "128px/a_trusted_friend-128.png",
	"auroraborealis" => "auroraborealis.png",
	"baby_in_a_box" => "1000px/baby_in_a_box.png",
	"bear" => "1000px/bear.png",
	"bear-128" => "128px/bear-128.png"
	}

	assert updated_pack.files_count == 5
	end

	test "skips existing emojis when adding from zip file", %{pack: pack} do
	# First, let's create a test pack with a "bear" emoji
	test_pack_path = Path.join(@emoji_path, "test_bear_pack")
	File.mkdir_p(test_pack_path)

	# Create a pack.json file
	File.write!(Path.join(test_pack_path, "pack.json"), """
	{
	"files": { "bear": "bear.png" },
	"pack": {
	"description": "Bear Pack", "homepage": "https://pleroma.social",
	"license": "Test license", "share-files": true
	}}
	""")

	# Copy a test image to use as the bear emoji
	File.cp!(
	Path.absname("test/instance_static/emoji/test_pack/blank.png"),
	Path.join(test_pack_path, "bear.png")
	)

	# Load the pack to register the "bear" emoji in the global registry
	{:ok, _bear_pack} = Pleroma.Emoji.Pack.load_pack("test_bear_pack")

	# Reload emoji to make sure the bear emoji is in the global registry
	Emoji.reload()

	# Verify that the bear emoji exists in the global registry
	assert Emoji.exist?("bear")

	# Now try to add a zip file that contains an emoji with the same shortcode
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)

	# Verify that the "bear" emoji was skipped
	refute Map.has_key?(updated_pack.files, "bear")

	# Other emojis should be added
	assert Map.has_key?(updated_pack.files, "a_trusted_friend-128")
	assert Map.has_key?(updated_pack.files, "auroraborealis")
	assert Map.has_key?(updated_pack.files, "baby_in_a_box")
	assert Map.has_key?(updated_pack.files, "bear-128")

	# Total count should be 4 (all emojis except "bear")
	assert updated_pack.files_count == 4

	# Clean up the test pack
	on_exit(fn ->
	File.rm_rf!(test_pack_path)
	end)
	end
	end

	test "returns error when zip file is bad", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/instance_static/emoji/test_pack/blank.png")
	}

	- assert Pack.add_file(pack, nil, nil, file) == {:error, :einval}
	+ assert {:error, _} = Pack.add_file(pack, nil, nil, file)
	end

	test "returns pack when zip file is empty", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/empty.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)
	assert updated_pack == pack
	end

	test "add emoji file", %{pack: pack} do
	file = %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}

	{:ok, updated_pack} = Pack.add_file(pack, "test_blank", "test_blank.png", file)

	assert updated_pack.files == %{
	"test_blank" => "test_blank.png"
	}

	assert updated_pack.files_count == 1
	end

	test "load_pack/1 ignores path traversal in a forged pack name", %{pack: pack} do
	assert {:ok, ^pack} = Pack.load_pack("../../../../../dump_pack")
	end
	end
	diff --git a/test/pleroma/notification_test.exs b/test/pleroma/notification_test.exs
	index e595c5c53..4b20e07cf 100644
	--- a/test/pleroma/notification_test.exs
	+++ b/test/pleroma/notification_test.exs
	@@ -1,1125 +1,1125 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import Pleroma.Factory

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

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

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

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

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

	test "creates a report notification only for privileged users" do
	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	clear_config([:instance, :moderator_privileges], [])
	{:ok, activity1} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, []} = Notification.create_notifications(activity1)

	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])
	{:ok, activity2} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity2)

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

	test "suppresses notifications for own reports" do
	clear_config([:instance, :admin_privileges], [:reports_manage_reports])

	reporting_admin = insert(:user, is_admin: true)
	reported_user = insert(:user)
	other_admin = insert(:user, is_admin: true)

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

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

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

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

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

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

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

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

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

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

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

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

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

	User.subscribe(subscriber, user)

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

	assert notification.user_id == subscriber.id
	assert notification.type == "status"
	end

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

	User.subscribe(subscriber, other_user)

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

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

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

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

	test "does not create subscriber notification if mentioned" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "mentioning @#{subscriber.nickname}"})
	{:ok, [notification] = notifications} = Notification.create_notifications(status)

	assert length(notifications) == 1

	assert notification.user_id == subscriber.id
	assert notification.type == "mention"
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute Notification.create_notification(activity, author)
	end

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

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

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

	User.subscribe(subscriber, user)

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

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

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

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

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

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

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

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

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

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

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

	assert notification
	refute notification.seen
	end

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

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

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

	assert notification
	refute notification.seen
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

	notification_id = notification.id
	assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
	end

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

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

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

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

	assert notification.user_id == other_user.id
	end

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

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

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

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

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

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

	assert notification.user_id == other_user.id
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert n2.id > n1.id

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

	Notification.set_read_up_to(other_user, n2.id)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user not in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

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

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(like)

	assert other_user not in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return thread-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(same_context_activity)

	refute other_user in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [other_user] == enabled_receivers
	end

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

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(edit_activity)

	assert repeated_user in enabled_receivers
	refute other_user in enabled_receivers
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	remote_user_url = remote_user.ap_id

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

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

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

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

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

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

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

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

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

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

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

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

	[notification] = Notification.for_user(user)

	assert notification.activity.object
	assert notification.seen
	end

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

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

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

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

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

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

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

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

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

	test "it returns notifications for domain-blocked but followed user" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")

	{:ok, user} = User.block_domain(user, "some-domain.com")
	{:ok, _, _} = User.follow(user, blocked)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end
	end
	end
	diff --git a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	index 9847781f0..99522994a 100644
	--- a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	+++ b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	@@ -1,72 +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
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	import Pleroma.Tests.Helpers
	alias Pleroma.ConfigDB

	- setup do: clear_config(Pleroma.Formatter)
	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/anonymize_filename_test.exs b/test/pleroma/upload/filter/anonymize_filename_test.exs
	index 9b94b91c3..0f817a5a1 100644
	--- a/test/pleroma/upload/filter/anonymize_filename_test.exs
	+++ b/test/pleroma/upload/filter/anonymize_filename_test.exs
	@@ -1,41 +1,48 @@
	# 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.AnonymizeFilenameTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	+ import Mox
	alias Pleroma.Upload
	+ alias Pleroma.StaticStubbedConfigMock, as: ConfigMock

	setup do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	upload_file = %Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg")
	}

	%{upload_file: upload_file}
	end

	- setup do: clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
	-
	test "it replaces filename on pre-defined text", %{upload_file: upload_file} do
	- clear_config([Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
	+ ConfigMock
	+ \|> stub(:get, fn [Upload.Filter.AnonymizeFilename, :text] -> "custom-file.png" end)
	+
	{:ok, :filtered, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
	assert name == "custom-file.png"
	end

	test "it replaces filename on pre-defined text expression", %{upload_file: upload_file} do
	- clear_config([Upload.Filter.AnonymizeFilename, :text], "custom-file.{extension}")
	+ ConfigMock
	+ \|> stub(:get, fn [Upload.Filter.AnonymizeFilename, :text] -> "custom-file.{extension}" end)
	+
	{:ok, :filtered, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
	assert name == "custom-file.jpg"
	end

	test "it replaces filename on random text", %{upload_file: upload_file} do
	+ ConfigMock
	+ \|> stub(:get, fn [Upload.Filter.AnonymizeFilename, :text] -> nil end)
	+
	{:ok, :filtered, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
	assert <<_::bytes-size(14)>> <> ".jpg" = name
	refute name == "an… image.jpg"
	end
	end
	diff --git a/test/pleroma/upload/filter/mogrifun_test.exs b/test/pleroma/upload/filter/mogrifun_test.exs
	index bf9b65589..4de998c88 100644
	--- a/test/pleroma/upload/filter/mogrifun_test.exs
	+++ b/test/pleroma/upload/filter/mogrifun_test.exs
	@@ -1,44 +1,34 @@
	# 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.MogrifunTest do
	- use Pleroma.DataCase
	- import Mock
	+ use Pleroma.DataCase, async: true
	+ import Mox

	alias Pleroma.Upload
	alias Pleroma.Upload.Filter
	+ alias Pleroma.MogrifyMock

	test "apply mogrify filter" do
	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	upload = %Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	- task =
	- Task.async(fn ->
	- assert_receive {:apply_filter, {}}, 4_000
	- end)
	+ MogrifyMock
	+ \|> stub(:open, fn _file -> %{} end)
	+ \|> stub(:custom, fn _image, _action -> %{} end)
	+ \|> stub(:custom, fn _image, _action, _options -> %{} end)
	+ \|> stub(:save, fn _image, [in_place: true] -> :ok end)

	- with_mocks([
	- {Mogrify, [],
	- [
	- open: fn _f -> %Mogrify.Image{} end,
	- custom: fn _m, _a -> send(task.pid, {:apply_filter, {}}) end,
	- custom: fn _m, _a, _o -> send(task.pid, {:apply_filter, {}}) end,
	- save: fn _f, _o -> :ok end
	- ]}
	- ]) do
	- assert Filter.Mogrifun.filter(upload) == {:ok, :filtered}
	- end
	-
	- Task.await(task)
	+ assert Filter.Mogrifun.filter(upload) == {:ok, :filtered}
	end
	end
	diff --git a/test/pleroma/upload/filter/mogrify_test.exs b/test/pleroma/upload/filter/mogrify_test.exs
	index 208da57ca..6826faafe 100644
	--- a/test/pleroma/upload/filter/mogrify_test.exs
	+++ b/test/pleroma/upload/filter/mogrify_test.exs
	@@ -1,41 +1,38 @@
	# 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.MogrifyTest do
	- use Pleroma.DataCase
	- import Mock
	+ use Pleroma.DataCase, async: true
	+ import Mox

	alias Pleroma.Upload.Filter
	+ alias Pleroma.StaticStubbedConfigMock, as: ConfigMock
	+ alias Pleroma.MogrifyMock
	+
	+ setup :verify_on_exit!

	test "apply mogrify filter" do
	- clear_config(Filter.Mogrify, args: [{"tint", "40"}])
	+ ConfigMock
	+ \|> stub(:get!, fn [Filter.Mogrify, :args] -> [{"tint", "40"}] end)

	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	upload = %Pleroma.Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	- task =
	- Task.async(fn ->
	- assert_receive {:apply_filter, {_, "tint", "40"}}, 4_000
	- end)
	-
	- with_mock Mogrify,
	- open: fn _f -> %Mogrify.Image{} end,
	- custom: fn _m, _a -> :ok end,
	- custom: fn m, a, o -> send(task.pid, {:apply_filter, {m, a, o}}) end,
	- save: fn _f, _o -> :ok end do
	- assert Filter.Mogrify.filter(upload) == {:ok, :filtered}
	- end
	+ MogrifyMock
	+ \|> expect(:open, fn _file -> %{} end)
	+ \|> expect(:custom, fn _image, "tint", "40" -> %{} end)
	+ \|> expect(:save, fn _image, [in_place: true] -> :ok end)

	- Task.await(task)
	+ assert Filter.Mogrify.filter(upload) == {:ok, :filtered}
	end
	end
	diff --git a/test/pleroma/upload/filter_test.exs b/test/pleroma/upload/filter_test.exs
	index 706fc9ac7..79bc369a6 100644
	--- a/test/pleroma/upload/filter_test.exs
	+++ b/test/pleroma/upload/filter_test.exs
	@@ -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.FilterTest do
	use Pleroma.DataCase

	+ import Mox
	alias Pleroma.Upload.Filter
	-
	- setup do: clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
	+ alias Pleroma.StaticStubbedConfigMock, as: ConfigMock

	test "applies filters" do
	- clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
	+ ConfigMock
	+ \|> stub(:get, fn [Pleroma.Upload.Filter.AnonymizeFilename, :text] -> "custom-file.png" end)

	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	upload = %Pleroma.Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	assert Filter.filter([], upload) == {:ok, upload}

	assert {:ok, upload} = Filter.filter([Pleroma.Upload.Filter.AnonymizeFilename], upload)
	assert upload.name == "custom-file.png"
	end
	end
	diff --git a/test/pleroma/user_relationship_test.exs b/test/pleroma/user_relationship_test.exs
	index 7d205a746..5b43cb2b6 100644
	--- a/test/pleroma/user_relationship_test.exs
	+++ b/test/pleroma/user_relationship_test.exs
	@@ -1,136 +1,142 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserRelationshipTest do
	+ alias Pleroma.DateTimeMock
	alias Pleroma.UserRelationship

	- use Pleroma.DataCase, async: false
	+ use Pleroma.DataCase, async: true

	- import Mock
	+ import Mox
	import Pleroma.Factory

	describe "*_exists?/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "returns false if record doesn't exist", %{users: [user1, user2]} do
	refute UserRelationship.block_exists?(user1, user2)
	refute UserRelationship.mute_exists?(user1, user2)
	refute UserRelationship.notification_mute_exists?(user1, user2)
	refute UserRelationship.reblog_mute_exists?(user1, user2)
	refute UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "returns true if record exists", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	assert UserRelationship.block_exists?(user1, user2)
	assert UserRelationship.mute_exists?(user1, user2)
	assert UserRelationship.notification_mute_exists?(user1, user2)
	assert UserRelationship.reblog_mute_exists?(user1, user2)
	assert UserRelationship.inverse_subscription_exists?(user1, user2)
	end
	end

	describe "create_*/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "creates user relationship record if it doesn't exist", %{users: [user1, user2]} do
	+ DateTimeMock
	+ \|> stub_with(Pleroma.DateTime.Impl)
	+
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	UserRelationship.create_block(user1, user2)
	UserRelationship.create_mute(user1, user2)
	UserRelationship.create_notification_mute(user1, user2)
	UserRelationship.create_reblog_mute(user1, user2)
	UserRelationship.create_inverse_subscription(user1, user2)

	assert UserRelationship.block_exists?(user1, user2)
	assert UserRelationship.mute_exists?(user1, user2)
	assert UserRelationship.notification_mute_exists?(user1, user2)
	assert UserRelationship.reblog_mute_exists?(user1, user2)
	assert UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "if record already exists, returns it", %{users: [user1, user2]} do
	- user_block =
	- with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
	- {:ok, %{inserted_at: ~N[2017-03-17 17:09:58]}} =
	- UserRelationship.create_block(user1, user2)
	- end
	+ fixed_datetime = ~N[2017-03-17 17:09:58]
	+
	+ Pleroma.DateTimeMock
	+ \|> expect(:utc_now, 2, fn -> fixed_datetime end)
	+
	+ {:ok, %{inserted_at: ^fixed_datetime}} = UserRelationship.create_block(user1, user2)

	- assert user_block == UserRelationship.create_block(user1, user2)
	+ # Test the idempotency without caring about the exact time
	+ assert {:ok, _} = UserRelationship.create_block(user1, user2)
	end
	end

	describe "delete_*/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "deletes user relationship record if it exists", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	assert {:ok, %UserRelationship{}} = UserRelationship.delete_block(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_mute(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_notification_mute(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_reblog_mute(user1, user2)

	assert {:ok, %UserRelationship{}} =
	UserRelationship.delete_inverse_subscription(user1, user2)

	refute UserRelationship.block_exists?(user1, user2)
	refute UserRelationship.mute_exists?(user1, user2)
	refute UserRelationship.notification_mute_exists?(user1, user2)
	refute UserRelationship.reblog_mute_exists?(user1, user2)
	refute UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "if record does not exist, returns {:ok, nil}", %{users: [user1, user2]} do
	assert {:ok, nil} = UserRelationship.delete_block(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_notification_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_reblog_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_inverse_subscription(user1, user2)
	end
	end
	end
	diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
	index 4a3d6bacc..c05241f50 100644
	--- a/test/pleroma/user_test.exs
	+++ b/test/pleroma/user_test.exs
	@@ -1,2992 +1,2992 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)

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

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

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

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

	assert user.tags == []
	end
	end

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

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

	assert expected_ap_id == User.ap_id(user)
	end

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

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

	assert expected_followers_collection == User.ap_followers(user)
	end

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

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

	assert expected_followers_collection == User.ap_following(user)
	end

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

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

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

	assert activity
	end

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

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

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

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

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

	CommonAPI.follow(locked, pending_follower)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute User.following?(follower, followed)
	end

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

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

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

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

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

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

	user = User.get_cached_by_id(user.id)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Pleroma.Emails.UserEmail.account_confirmation_email(registered_user)
	# temporary hackney fix until hackney max_connections bug is fixed
	# https://git.pleroma.social/pleroma/pleroma/-/issues/2101
	\|> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
	\|> assert_email_sent()
	end

	test "sends a pending approval email" do
	clear_config([:instance, :account_approval_required], true)

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

	ObanHelpers.perform_all()

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

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

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

	ObanHelpers.perform_all()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert is_binary(restricted_name)

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

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

	refute changeset.valid?
	end

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

	assert is_binary(restricted_name)

	restricted_upcase_name = String.upcase(restricted_name)

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

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

	refute changeset.valid?
	end

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

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

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

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

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

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

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

	assert changeset.valid?

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

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

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

	assert user.accepts_chat_messages
	end

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

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

	assert user.is_confirmed
	end
	end

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

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

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

	refute user.is_confirmed
	assert user.confirmation_token
	end

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

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

	assert user.is_confirmed
	refute user.confirmation_token
	end
	end

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

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

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

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

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

	assert is_integer(reason_limit)

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

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

	refute changeset.valid?
	end
	end

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

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

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

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

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

	assert changeset.valid?
	end

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

	refute changeset.valid?
	end

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

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

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

	refute changeset.valid?
	end
	end

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

	assert user == fetched_user
	end

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

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

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

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

	assert user == fetched_user
	end
	end

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

	test "for mastodon" do
	ap_id = "a@mastodon.example"
	{:ok, fetched_user} = User.get_or_fetch(ap_id)

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

	test "for pleroma" do
	ap_id = "a@pleroma.example"
	{:ok, fetched_user} = User.get_or_fetch(ap_id)

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

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

	assert user == fetched_user
	end

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

	assert user == fetched_user
	end

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

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

	assert user == fetched_user
	end

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

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

	assert user == fetched_user
	end

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

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

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

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

	assert orig_user.last_refreshed_at == a_week_ago

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

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

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

	assert updated_user.inbox

	refute updated_user.last_refreshed_at == orig_user.last_refreshed_at
	end

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

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

	assert orig_user.last_refreshed_at == a_week_ago

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

	assert user.inbox

	refute user.id == orig_user.id

	orig_user = User.get_by_id(orig_user.id)

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

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

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

	assert orig_user.last_refreshed_at == a_week_ago

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

	assert user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

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

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

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

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

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

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

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

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

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

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

	refute cs.valid?
	end

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

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

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

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

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

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

	res = User.get_followers(user)

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

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

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

	res = User.get_friends(user)

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

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

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

	assert user.note_count == 0

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

	assert user.note_count == 1
	end

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

	assert user.note_count == 0

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

	assert user.note_count == 1

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

	assert user.note_count == 2
	end

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

	assert user.note_count == 0

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

	assert user.note_count == 1

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

	assert user.note_count == 0

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

	assert user.note_count == 0
	end

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

	User.follow(follower, user)

	assert user.follower_count == 0

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

	assert user.follower_count == 1
	end
	end

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

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

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

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

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

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

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

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)

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

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

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

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

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

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

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

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

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

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

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

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

	refute User.blocks?(user, blocked_user)

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

	assert User.blocks?(user, blocked_user)
	end

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

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

	refute User.blocks?(user, blocked_user)
	end

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

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

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

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

	assert User.blocks?(blocker, blocked)

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

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

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

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

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

	assert User.blocks?(blocker, blocked)

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

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

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

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

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

	assert User.blocks?(blocker, blocked)

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

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

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

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

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

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

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

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

	assert User.blocks?(user, collateral_user)
	end

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

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

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

	refute User.blocks?(user, collateral_user)
	end

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

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

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

	refute User.blocks?(user, collateral_user)
	end

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

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

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

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

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

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

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

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

	refute User.blocks?(user, collateral_user)
	end

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

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

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

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

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

	recipients = User.get_recipients_from_activity(announce)

	assert user in recipients
	end

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

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

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

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

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

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

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

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

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

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

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

	user2 = User.get_cached_by_id(user2.id)

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

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

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

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

	user2 = User.get_cached_by_id(user2.id)

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

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

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

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

	activity = Repo.preload(activity, :bookmark)

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

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

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

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

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

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

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

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

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

	assert Enum.count(users) == 3

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

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

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

	User.approve(user)

	ObanHelpers.perform_all()

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

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

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

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

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

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

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

	assert Enum.count(users) == 3

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

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

	ObanHelpers.perform_all()

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

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

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

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

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

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

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

	[user: user]
	end

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

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

	User.delete_user_activities(user)

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

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

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

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

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

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

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

	follower = User.get_cached_by_id(follower.id)

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

	assert [] == User.get_follow_requests(locked_user)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert Enum.count(users) == 3

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert cached_user != user

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

	assert cached_user != user
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert User.privileged?(user, :cofe)

	clear_config([:instance, :moderator_privileges], [])

	refute User.privileged?(user, :cofe)
	end

	test "returns true for local admins if, and only if, they are privileged" do
	user = insert(:user, local: true, is_admin: true)

	assert User.privileged?(user, :cofe)

	clear_config([:instance, :admin_privileges], [])

	refute User.privileged?(user, :cofe)
	end
	end

	describe "privileges/1" do
	setup do
	clear_config([:instance, :moderator_privileges], [:cofe, :only_moderator])
	clear_config([:instance, :admin_privileges], [:cofe, :only_admin])
	end

	test "returns empty list for users without roles" do
	user = insert(:user, local: true)

	assert [] == User.privileges(user)
	end

	test "returns list of privileges for moderators" do
	moderator = insert(:user, is_moderator: true, local: true)

	assert [:cofe, :only_moderator] == User.privileges(moderator) \|> Enum.sort()
	end

	test "returns list of privileges for admins" do
	admin = insert(:user, is_admin: true, local: true)

	assert [:cofe, :only_admin] == User.privileges(admin) \|> Enum.sort()
	end

	test "returns list of unique privileges for users who are both moderator and admin" do
	moderator_admin = insert(:user, is_moderator: true, is_admin: true, local: true)

	assert [:cofe, :only_admin, :only_moderator] ==
	User.privileges(moderator_admin) \|> Enum.sort()
	end

	test "returns empty list for remote users" do
	remote_moderator_admin = insert(:user, is_moderator: true, is_admin: true, local: false)

	assert [] == User.privileges(remote_moderator_admin)
	end
	end

	describe "invisible?/1" do
	test "returns true for an invisible user" do
	user = insert(:user, local: true, invisible: true)

	assert User.invisible?(user)
	end

	test "returns false for a non-invisible user" do
	user = insert(:user, local: true)

	refute User.invisible?(user)
	end
	end

	describe "visible_for/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for(user, user) == :visible
	end

	test "returns false when the account is unconfirmed and confirmation is required" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true)

	refute User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: false, is_confirmed: false)
	other_user = insert(:user, local: true)

	assert User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and being viewed by a privileged account (privilege :users_manage_activation_state, confirmation required)" do
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :admin_privileges], [:users_manage_activation_state])

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true, is_admin: true)

	assert User.visible_for(user, other_user) == :visible

	clear_config([:instance, :admin_privileges], [])

	refute User.visible_for(user, other_user) == :visible
	end
	end

	describe "all_users_with_privilege/1" do
	setup do
	%{
	user: insert(:user, local: true, is_admin: false, is_moderator: false),
	moderator_user: insert(:user, local: true, is_admin: false, is_moderator: true),
	admin_user: insert(:user, local: true, is_admin: true, is_moderator: false),
	admin_moderator_user: insert(:user, local: true, is_admin: true, is_moderator: true),
	remote_user: insert(:user, local: false, is_admin: true, is_moderator: true),
	non_active_user:
	insert(:user, local: true, is_admin: true, is_moderator: true, is_active: false)
	}
	end

	test "doesn't return any users when there are no privileged roles" do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [])

	assert [] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	end

	test "returns moderator users if they are privileged", %{
	moderator_user: moderator_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [:cofe])

	assert [_, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert moderator_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end

	test "returns admin users if they are privileged", %{
	admin_user: admin_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [:cofe])
	clear_config([:instance, :moderator_privileges], [])

	assert [_, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert admin_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end

	test "returns admin and moderator users if they are both privileged", %{
	moderator_user: moderator_user,
	admin_user: admin_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [:cofe])
	clear_config([:instance, :moderator_privileges], [:cofe])

	assert [_, _, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert admin_user in User.all_users_with_privilege(:cofe)
	assert moderator_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	~s(A.k.a. <span class="h-card"><a class="u-url mention" data-user="#{remote_user.id}" href="#{remote_user.ap_id}" rel="ugc">@<span>nick@domain.com</span></a></span>)

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	bio = "http://example.com/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/link"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower, user} = User.follow(follower, user)
	{:ok, _follower2, _user} = User.follow(follower2, user)
	{:ok, _follower3, _user} = User.follow(follower3, user)

	{:ok, _user_relationship} = User.block(user, follower)
	user = refresh_record(user)

	assert user.follower_count == 2
	end

	describe "list_inactive_users_query/1" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Users are inactive by default" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(users, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users who has no recent activity" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	{inactive, active} = Enum.split(users, trunc(total / 2))

	Enum.map(active, fn user ->
	to = Enum.random(users -- [user])

	{:ok, _} =
	CommonAPI.post(user, %{
	status: "hey @#{to.nickname}"
	})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users with no read notifications" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	[sender \| recipients] = users
	{inactive, active} = Enum.split(recipients, trunc(total / 2))

	Enum.each(recipients, fn to ->
	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey @#{to.nickname}"
	})

	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey again @#{to.nickname}"
	})
	end)

	Enum.each(active, fn user ->
	[n1, _n2] = Pleroma.Notification.for_user(user)
	{:ok, _} = Pleroma.Notification.read_one(user, n1.id)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end
	end

	describe "get_ap_ids_by_nicknames" do
	test "it returns a list of AP ids for a given set of nicknames" do
	user = insert(:user)
	user_two = insert(:user)

	ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
	assert length(ap_ids) == 2
	assert user.ap_id in ap_ids
	assert user_two.ap_id in ap_ids
	end

	test "it returns a list of AP ids in the same order" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	ap_ids =
	User.get_ap_ids_by_nicknames([user.nickname, user_three.nickname, user_two.nickname])

	assert [user.ap_id, user_three.ap_id, user_two.ap_id] == ap_ids
	end
	end

	describe "sync followers count" do
	setup do
	user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
	user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
	insert(:user, local: true)
	insert(:user, local: false, is_active: false)
	{:ok, user1: user1, user2: user2}
	end

	test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
	[fdb_user1] = User.external_users(limit: 1)

	assert fdb_user1.ap_id
	assert fdb_user1.ap_id == user1.ap_id
	assert fdb_user1.id == user1.id

	[fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)

	assert fdb_user2.ap_id
	assert fdb_user2.ap_id == user2.ap_id
	assert fdb_user2.id == user2.id

	assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
	end
	end

	describe "internal?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.internal?(user)
	end

	test "user with no nickname returns true" do
	user = insert(:user, %{nickname: nil})
	assert User.internal?(user)
	end

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.internal?(user)
	end
	end

	describe "update_and_set_cache/1" do
	test "returns error when user is stale instead Ecto.StaleEntryError" do
	user = insert(:user)

	changeset = Ecto.Changeset.change(user, bio: "test")

	Repo.delete(user)

	assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
	User.update_and_set_cache(changeset)
	end

	test "performs update cache if user updated" do
	user = insert(:user)
	assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	changeset = Ecto.Changeset.change(user, bio: "test-bio")

	assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
	assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
	end
	end

	describe "following/followers synchronization" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "updates the counters normally on following/getting a follow when disabled" do
	clear_config([:instance, :external_user_synchronization], false)
	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	{:ok, user, other_user} = Pleroma.User.follow(user, other_user)

	assert user.following_count == 1
	assert other_user.follower_count == 1
	end

	test "synchronizes the counters with the remote instance for the followed when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, _user, other_user} = User.follow(user, other_user)

	assert other_user.follower_count == 437
	end

	test "synchronizes the counters with the remote instance for the follower when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, other_user, _user} = User.follow(other_user, user)

	assert other_user.following_count == 152
	end
	end

	describe "change_email/2" do
	setup do
	[user: insert(:user)]
	end

	test "blank email returns error if we require an email on registration", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], true)

	on_exit(fn ->
	Pleroma.Config.put(
	[:instance, :account_activation_required],
	orig_account_activation_required
	)
	end)

	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
	end

	test "blank email should be fine if we do not require an email on registration", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], false)

	on_exit(fn ->
	Pleroma.Config.put(
	[:instance, :account_activation_required],
	orig_account_activation_required
	)
	end)

	assert {:ok, %User{email: nil}} = User.change_email(user, "")
	assert {:ok, %User{email: nil}} = User.change_email(user, nil)
	end

	test "non unique email returns error", %{user: user} do
	%{email: email} = insert(:user)

	assert {:error, %{errors: [email: {"has already been taken", _}]}} =
	User.change_email(user, email)
	end

	test "invalid email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"has invalid format", _}]}} =
	User.change_email(user, "cofe")
	end

	test "changes email", %{user: user} do
	assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
	end

	test "adds email", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], false)

	on_exit(fn ->
	Pleroma.Config.put(
	[:instance, :account_activation_required],
	orig_account_activation_required
	)
	end)

	assert {:ok, _} = User.change_email(user, "")
	Pleroma.Config.put([:instance, :account_activation_required], true)

	assert {:ok, %User{email: "cofe2@cofe.party"}} = User.change_email(user, "cofe2@cofe.party")
	end
	end

	describe "get_cached_by_nickname_or_id" do
	setup do
	local_user = insert(:user)
	remote_user = insert(:user, nickname: "nickname@example.com", local: false)

	[local_user: local_user, remote_user: remote_user]
	end

	setup do: clear_config([:instance, :limit_to_local_content])

	test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
	remote_user: remote_user
	} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
	end

	test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user, local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
	end

	test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], true)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
	%{local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
	end
	end

	describe "update_email_notifications/2" do
	setup do
	user = insert(:user, email_notifications: %{"digest" => true})

	{:ok, user: user}
	end

	test "Notifications are updated", %{user: user} do
	true = user.email_notifications["digest"]
	assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
	assert result.email_notifications["digest"] == false
	end
	end

	describe "local_nickname/1" do
	test "returns nickname without host" do
	assert User.local_nickname("@mentioned") == "mentioned"
	assert User.local_nickname("a_local_nickname") == "a_local_nickname"
	assert User.local_nickname("nickname@host.com") == "nickname"
	end
	end

	describe "full_nickname/1" do
	test "returns fully qualified nickname for local users" do
	local_user = insert(:user, nickname: "local_user")

	assert User.full_nickname(local_user) == "local_user@localhost"
	end

	test "returns fully qualified nickname for local users when using different domain for webfinger" do
	clear_config([Pleroma.Web.WebFinger, :domain], "plemora.dev")

	local_user = insert(:user, nickname: "local_user")

	assert User.full_nickname(local_user) == "local_user@plemora.dev"
	end

	test "returns fully qualified nickname for remote users" do
	remote_user = insert(:user, nickname: "remote@host.com", local: false)

	assert User.full_nickname(remote_user) == "remote@host.com"
	end

	test "strips leading @ from mentions" do
	assert User.full_nickname("@mentioned") == "mentioned"
	assert User.full_nickname("@nickname@host.com") == "nickname@host.com"
	end

	test "does not modify nicknames" do
	assert User.full_nickname("nickname") == "nickname"
	assert User.full_nickname("nickname@host.com") == "nickname@host.com"
	end
	end

	test "avatar fallback" do
	user = insert(:user)
	assert User.avatar_url(user) =~ "/images/avi.png"

	clear_config([:assets, :default_user_avatar], "avatar.png")

	user = User.get_cached_by_nickname_or_id(user.nickname)
	assert User.avatar_url(user) =~ "avatar.png"

	assert User.avatar_url(user, no_default: true) == nil
	end

	test "get_host/1" do
	user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
	assert User.get_host(user) == "lain.com"
	end

	test "update_last_active_at/1" do
	user = insert(:user)
	assert is_nil(user.last_active_at)

	test_started_at = NaiveDateTime.utc_now() \|> NaiveDateTime.truncate(:second)

	assert {:ok, user} = User.update_last_active_at(user)

	assert user.last_active_at >= test_started_at
	assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	last_active_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(-:timer.hours(24), :millisecond)
	\|> NaiveDateTime.truncate(:second)

	assert {:ok, user} =
	user
	\|> cast(%{last_active_at: last_active_at}, [:last_active_at])
	\|> User.update_and_set_cache()

	assert user.last_active_at == last_active_at
	assert {:ok, user} = User.update_last_active_at(user)
	assert user.last_active_at >= test_started_at
	assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	end

	test "active_user_count/1" do
	insert(:user)
	insert(:user, %{local: false})
	insert(:user, %{last_active_at: NaiveDateTime.utc_now()})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), days: -15)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -6)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), months: -7)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), years: -2)})

	assert User.active_user_count() == 2
	assert User.active_user_count(180) == 3
	assert User.active_user_count(365) == 4
	assert User.active_user_count(1000) == 5
	end

	describe "pins" do
	setup do
	user = insert(:user)

	[user: user, object_id: object_id_from_created_activity(user)]
	end

	test "unique pins", %{user: user, object_id: object_id} do
	assert {:ok, %{pinned_objects: %{^object_id => pinned_at1} = pins} = updated_user} =
	User.add_pinned_object_id(user, object_id)

	assert Enum.count(pins) == 1

	assert {:ok, %{pinned_objects: %{^object_id => pinned_at2} = pins}} =
	User.add_pinned_object_id(updated_user, object_id)

	assert pinned_at1 == pinned_at2

	assert Enum.count(pins) == 1
	end

	test "respects max_pinned_statuses limit", %{user: user, object_id: object_id} do
	clear_config([:instance, :max_pinned_statuses], 1)
	{:ok, updated} = User.add_pinned_object_id(user, object_id)

	object_id2 = object_id_from_created_activity(user)

	{:error, %{errors: errors}} = User.add_pinned_object_id(updated, object_id2)
	assert Keyword.has_key?(errors, :pinned_objects)
	end

	test "remove_pinned_object_id/2", %{user: user, object_id: object_id} do
	assert {:ok, updated} = User.add_pinned_object_id(user, object_id)

	{:ok, after_remove} = User.remove_pinned_object_id(updated, object_id)
	assert after_remove.pinned_objects == %{}
	end
	end

	defp object_id_from_created_activity(user) do
	%{id: id} = insert(:note_activity, user: user)
	%{object: %{data: %{"id" => object_id}}} = Activity.get_by_id_with_object(id)
	object_id
	end

	describe "add_alias/2" do
	test "should add alias for another user" do
	user = insert(:user)
	user2 = insert(:user)

	assert {:ok, user_updated} = user \|> User.add_alias(user2)

	assert user_updated.also_known_as \|> length() == 1
	assert user2.ap_id in user_updated.also_known_as
	end

	test "should add multiple aliases" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	assert {:ok, user} = user \|> User.add_alias(user2)
	assert {:ok, user_updated} = user \|> User.add_alias(user3)

	assert user_updated.also_known_as \|> length() == 2
	assert user2.ap_id in user_updated.also_known_as
	assert user3.ap_id in user_updated.also_known_as
	end

	test "should not add duplicate aliases" do
	user = insert(:user)
	user2 = insert(:user)

	assert {:ok, user} = user \|> User.add_alias(user2)

	assert {:ok, user_updated} = user \|> User.add_alias(user2)

	assert user_updated.also_known_as \|> length() == 1
	assert user2.ap_id in user_updated.also_known_as
	end
	end

	describe "alias_users/1" do
	test "should get aliases for a user" do
	user = insert(:user)
	user2 = insert(:user, also_known_as: [user.ap_id])

	aliases = user2 \|> User.alias_users()

	assert aliases \|> length() == 1

	alias_user = aliases \|> Enum.at(0)

	assert alias_user.ap_id == user.ap_id
	end
	end

	describe "delete_alias/2" do
	test "should delete existing alias" do
	user = insert(:user)
	user2 = insert(:user, also_known_as: [user.ap_id])

	assert {:ok, user_updated} = user2 \|> User.delete_alias(user)

	assert user_updated.also_known_as == []
	end

	test "should report error on non-existing alias" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user, also_known_as: [user.ap_id])

	assert {:error, :no_such_alias} = user3 \|> User.delete_alias(user2)

	user3_updated = User.get_cached_by_ap_id(user3.ap_id)

	assert user3_updated.also_known_as \|> length() == 1
	assert user.ap_id in user3_updated.also_known_as
	end
	end

	describe "get_familiar_followers/3" do
	test "returns familiar followers for a pair of users" do
	user1 = insert(:user)
	%{id: id2} = user2 = insert(:user)
	user3 = insert(:user)
	_user4 = insert(:user)

	User.follow(user1, user2)
	User.follow(user2, user3)

	assert [%{id: ^id2}] = User.get_familiar_followers(user3, user1)
	end
	end

	describe "account endorsements" do
	test "it pins people" do
	user = insert(:user)
	pinned_user = insert(:user)

	{:ok, _pinned_user, _user} = User.follow(user, pinned_user)

	refute User.endorses?(user, pinned_user)

	{:ok, _user_relationship} = User.endorse(user, pinned_user)

	assert User.endorses?(user, pinned_user)
	end

	test "it unpins users" do
	user = insert(:user)
	pinned_user = insert(:user)

	{:ok, _pinned_user, _user} = User.follow(user, pinned_user)
	{:ok, _user_relationship} = User.endorse(user, pinned_user)
	{:ok, _user_pin} = User.unendorse(user, pinned_user)

	refute User.endorses?(user, pinned_user)
	end

	test "it doesn't pin users you do not follow" do
	user = insert(:user)
	pinned_user = insert(:user)

	assert {:error, _message} = User.endorse(user, pinned_user)

	refute User.endorses?(user, pinned_user)
	end
	end

	test "it checks fields links for a backlink" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	fields = [
	%{"name" => "Link", "value" => "http://example.com/rel_me/null"},
	%{"name" => "Verified link", "value" => "http://example.com/rel_me/link"},
	%{"name" => "Not a link", "value" => "i'm not a link"}
	]

	user
	\|> User.update_and_set_cache(%{raw_fields: fields})

	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	assert [
	%{"verified_at" => nil},
	%{"verified_at" => verified_at},
	%{"verified_at" => nil}
	] = user.fields

	assert is_binary(verified_at)
	end

	test "updating fields does not invalidate previously validated links" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	user
	\|> User.update_and_set_cache(%{
	raw_fields: [%{"name" => "verified link", "value" => "http://example.com/rel_me/link"}]
	})

	ObanHelpers.perform_all()

	%User{fields: [%{"verified_at" => verified_at}]} = user = User.get_cached_by_id(user.id)

	user
	\|> User.update_and_set_cache(%{
	raw_fields: [%{"name" => "Verified link", "value" => "http://example.com/rel_me/link"}]
	})

	user = User.get_cached_by_id(user.id)

	assert [%{"verified_at" => ^verified_at}] = user.fields
	end

	describe "follow_hashtag/2" do
	test "should follow a hashtag" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 1
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end

	test "should not follow a hashtag twice" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 1
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end

	test "can follow multiple hashtags" do
	user = insert(:user)
	hashtag = insert(:hashtag)
	other_hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.follow_hashtag(other_hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 2
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	assert other_hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end
	end

	describe "unfollow_hashtag/2" do
	test "should unfollow a hashtag" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 0
	end

	test "should not error when trying to unfollow a hashtag twice" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 0
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	index 4edca14d8..46b3d5f0d 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,2256 +1,2256 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Workers.ReceiverWorker

	import Pleroma.Factory

	require Pleroma.Constants

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :federating], true)

	describe "/relay" do
	setup do: clear_config([:instance, :allow_relay])

	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	clear_config([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end
	end

	describe "/internal/fetch" do
	test "it returns the internal fetch user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(200)

	assert res["id"] =~ "/fetch"
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(404)
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user with accept application/json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/activity+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/ld+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns 404 for remote users", %{
	conn: conn
	} do
	user = insert(:user, local: false, nickname: "remoteuser@example.com")

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}.json")

	assert json_response(conn, 404)
	end

	test "it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end
	end

	describe "mastodon compatibility routes" do
	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "it returns a json representation of the activity with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	{:ok, activity, _} =
	%{
	"id" => object.data["id"] <> "/activity",
	"type" => "Create",
	"object" => object.data["id"],
	"actor" => object.data["actor"],
	"to" => object.data["to"]
	}
	\|> ActivityPub.persist(local: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999/activity")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end
	end

	describe "/objects/:uuid" do
	test "it doesn't return a local-only object", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns local-only objects when authenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(response, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "does not return local-only objects for remote users", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user, local: false)

	{:ok, post} =
	CommonAPI.post(user, %{status: "test @#{reader.nickname}", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	json_response(response, 404)
	end

	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/activity+json",
	%{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/ld+json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "does not cache authenticated response", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user)

	{:ok, post} =
	CommonAPI.post(user, %{status: "test @#{reader.nickname}", visibility: "local"})

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	json_response(response, 200)

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(404)
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns visible non-public messages when authenticated", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()
	user = User.get_by_ap_id(note.data["actor"])
	marisa = insert(:user)

	assert conn
	\|> assign(:user, marisa)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(404)

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(200)

	assert response == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after object deletion", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Object.delete(note)

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/activities/:uuid" do
	test "it doesn't return a local-only activity", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns local-only activities when authenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(response, 200) == ObjectView.render("object.json", %{object: post})
	end

	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns visible non-public messages when authenticated", %{conn: conn} do
	note = insert(:direct_note_activity)
	uuid = String.split(note.data["id"], "/") \|> List.last()
	user = User.get_by_ap_id(note.data["actor"])
	marisa = insert(:user)

	assert conn
	\|> assign(:user, marisa)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")
	\|> json_response(404)

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")
	\|> json_response(200)

	assert response == ObjectView.render("object.json", %{object: note})
	end

	test "it caches a response", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after activity deletion", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe"})

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Activity.delete_all_by_object_ap_id(activity.object.data["id"])

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it inserts an incoming activity into the database" <>
	"even if we can't fetch the user but have it in our db",
	%{conn: conn} do
	user =
	insert(:user,
	ap_id: "https://mastodon.example.org/users/raymoo",
	local: false,
	last_refreshed_at: nil
	)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> put_in(["object", "attributedTo"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	sender_url = data["actor"]
	Instances.set_consistently_unreachable(sender_url)
	refute Instances.reachable?(sender_url)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_url)
	end

	test "accept follow activity", %{conn: conn} do
	clear_config([:instance, :federating], true)
	relay = Relay.get_actor()

	assert {:ok, %Activity{} = activity} = Relay.follow("https://relay.mastodon.host/actor")

	followed_relay = Pleroma.User.get_by_ap_id("https://relay.mastodon.host/actor")
	relay = refresh_record(relay)

	accept =
	File.read!("test/fixtures/relay/accept-follow.json")
	\|> String.replace("{{ap_id}}", relay.ap_id)
	\|> String.replace("{{activity_id}}", activity.data["id"])

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", accept)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.FollowingRelationship.following?(
	relay,
	followed_relay
	)

	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])
	assert_receive {:mix_shell, :info, ["https://relay.mastodon.host/actor"]}
	end

	test "without valid signature, " <>
	"it accepts Create activities and requires enabled federation",
	%{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()
	non_create_data = File.read!("test/fixtures/mastodon-announce.json") \|> Jason.decode!()

	conn = put_req_header(conn, "content-type", "application/activity+json")

	clear_config([:instance, :federating], false)

	conn
	\|> post("/inbox", data)
	\|> json_response(403)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(403)

	clear_config([:instance, :federating], true)

	ret_conn = post(conn, "/inbox", data)
	assert "ok" == json_response(ret_conn, 200)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(400)
	end

	# When activity is delivered to the inbox and we cannot immediately verify signature
	# we capture all the params and process it later in the Oban job.
	# Once we begin processing it through Oban we risk fetching the actor to validate the
	# activity which just leads to inserting a new user to process a Delete not relevant to us.
	test "Activities of certain types from an unknown actor are discarded", %{conn: conn} do
	example_bad_types =
	Pleroma.Constants.activity_types() --
	Pleroma.Constants.allowed_activity_types_from_strangers()

	Enum.each(example_bad_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	"actor" => "https://unknown.mastodon.instance/users/somebody"
	}
	\|> Jason.encode!()

	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", params)
	\|> json_response(400)

	assert all_enqueued() == []
	end)
	end

	test "Unknown activity types are discarded", %{conn: conn} do
	unknown_types = ["Poke", "Read", "Dazzle"]

	Enum.each(unknown_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	"actor" => "https://unknown.mastodon.instance/users/somebody"
	}
	\|> Jason.encode!()

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", params)
	\|> json_response(400)

	assert all_enqueued() == []
	end)
	end

	test "accepts Add/Remove activities", %{conn: conn} do
	object_id = "c61d6733-e256-4fe1-ab13-1e369789423f"

	status =
	File.read!("test/fixtures/statuses/note.json")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	user =
	File.read!("test/fixtures/users_mock/user.json")
	\|> String.replace("{{nickname}}", "lain")

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: status,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423f",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()]
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	user = User.get_cached_by_ap_id(data["actor"])
	assert user.pinned_objects[data["object"]]

	data = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423d",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()]
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	user = refresh_record(user)
	refute user.pinned_objects[data["object"]]
	end

	test "mastodon pin/unpin", %{conn: conn} do
	status_id = "105786274556060421"

	status =
	File.read!("test/fixtures/statuses/masto-note.json")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{status_id}}", status_id)

	status_url = "https://example.com/users/lain/statuses/#{status_id}"

	user =
	File.read!("test/fixtures/users_mock/user.json")
	\|> String.replace("{{nickname}}", "lain")

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^status_url
	} ->
	%Tesla.Env{
	status: 200,
	body: status,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => actor,
	"object" => status_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add"
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_object_ap_id_with_object(data["object"])
	user = User.get_cached_by_ap_id(data["actor"])
	assert user.pinned_objects[data["object"]]

	data = %{
	"actor" => actor,
	"object" => status_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove"
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_object_ap_id_with_object(data["object"])
	user = refresh_record(user)
	refute user.pinned_objects[data["object"]]
	end
	end

	describe "/users/:nickname/inbox" do
	setup do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	[data: data]
	end

	test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects an invalid incoming activity", %{conn: conn, data: data} do
	user = insert(:user, is_active: false)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "Invalid request." == json_response(conn, 400)
	end

	test "it accepts messages with to as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", user.ap_id)
	\|> Map.put("cc", [])
	\|> Kernel.put_in(["object", "to"], user.ap_id)
	\|> Kernel.put_in(["object", "cc"], [])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with cc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", [])
	\|> Map.put("cc", user.ap_id)
	\|> Kernel.put_in(["object", "to"], [])
	\|> Kernel.put_in(["object", "cc"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert user.ap_id in activity.recipients
	end

	test "it accepts messages with bcc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", [])
	\|> Map.put("cc", [])
	\|> Map.put("bcc", user.ap_id)
	\|> Kernel.put_in(["object", "to"], [])
	\|> Kernel.put_in(["object", "cc"], [])
	\|> Kernel.put_in(["object", "bcc"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts announces with to as string instead of array", %{conn: conn} do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "hey"})
	announcer = insert(:user, local: false)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => announcer.ap_id,
	"id" => "#{announcer.ap_id}/statuses/19512778738411822/activity",
	"object" => post.data["object"],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => [user.ap_id],
	"type" => "Announce"
	}

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.recipients
	end

	test "it accepts messages from actors that are followed by the user", %{
	conn: conn,
	data: data
	} do
	recipient = insert(:user)
	actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})

	{:ok, recipient, actor} = User.follow(recipient, actor)

	object =
	data["object"]
	\|> Map.put("attributedTo", actor.ap_id)

	data =
	data
	\|> Map.put("actor", actor.ap_id)
	\|> Map.put("object", object)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	sender_host = URI.parse(data["actor"]).host
	Instances.set_consistently_unreachable(sender_host)
	refute Instances.reachable?(sender_host)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_host)
	end

	test "it removes all follower collections but actor's", %{conn: conn} do
	[actor, recipient] = insert_pair(:user)

	to = [
	recipient.ap_id,
	recipient.follower_address,
	"https://www.w3.org/ns/activitystreams#Public"
	]

	cc = [recipient.follower_address, actor.follower_address]

	data = %{
	"@context" => ["https://www.w3.org/ns/activitystreams"],
	"type" => "Create",
	"id" => Utils.generate_activity_id(),
	"to" => to,
	"cc" => cc,
	"actor" => actor.ap_id,
	"object" => %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => "It's a note",
	"attributedTo" => actor.ap_id,
	"id" => Utils.generate_object_id()
	}
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert activity = Activity.get_by_ap_id(data["id"])

	assert activity.id
	assert actor.follower_address in activity.recipients
	assert actor.follower_address in activity.data["cc"]

	refute recipient.follower_address in activity.recipients
	refute recipient.follower_address in activity.data["cc"]
	refute recipient.follower_address in activity.data["to"]
	end

	test "it requires authentication", %{conn: conn} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "application/activity+json")

	ret_conn = get(conn, "/users/#{user.nickname}/inbox")
	assert json_response(ret_conn, 403)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(ret_conn, 200)
	end

	test "forwarded report", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	reported_user = insert(:user)

	note = insert(:note_activity, user: reported_user)

	data = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://#{remote_domain}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	],
	"actor" => actor.ap_id,
	"cc" => [
	reported_user.ap_id
	],
	"content" => "test",
	"context" => "context",
	"id" => "http://#{remote_domain}/activities/02be56cf-35e3-46b4-b2c6-47ae08dfee9e",
	"nickname" => reported_user.nickname,
	"object" => [
	reported_user.ap_id,
	%{
	"actor" => %{
	"actor_type" => "Person",
	"approval_pending" => false,
	"avatar" => "",
	"confirmation_pending" => false,
	"deactivated" => false,
	"display_name" => "test user",
	"id" => reported_user.id,
	"local" => false,
	"nickname" => reported_user.nickname,
	"registration_reason" => nil,
	"roles" => %{
	"admin" => false,
	"moderator" => false
	},
	"tags" => [],
	"url" => reported_user.ap_id
	},
	"content" => "",
	"id" => note.data["id"],
	"published" => note.data["published"],
	"type" => "Note"
	}
	],
	"published" => note.data["published"],
	"state" => "open",
	"to" => [],
	"type" => "Flag"
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.Repo.aggregate(Activity, :count, :id) == 2

	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/Reported Account:/i
	)
	end

	test "forwarded report from mastodon", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	remote_actor = "https://#{remote_domain}/actor"
	[reported_user, another] = insert_list(2, :user)

	note = insert(:note_activity, user: reported_user)

	Pleroma.Web.CommonAPI.favorite(note.id, another)

	mock_json_body =
	"test/fixtures/mastodon/application_actor.json"
	\|> File.read!()
	\|> String.replace("{{DOMAIN}}", remote_domain)

	Tesla.Mock.mock(fn %{url: ^remote_actor} ->
	%Tesla.Env{
	status: 200,
	body: mock_json_body,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => remote_actor,
	"content" => "test report",
	"id" => "https://#{remote_domain}/e3b12fd1-948c-446e-b93b-a5e67edbe1d8",
	"object" => [
	reported_user.ap_id,
	note.data["object"]
	],
	"type" => "Flag"
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	flag_activity = "Flag" \|> Pleroma.Activity.Queries.by_type() \|> Pleroma.Repo.one()
	reported_user_ap_id = reported_user.ap_id

	[^reported_user_ap_id, flag_data] = flag_activity.data["object"]

	Enum.each(~w(actor content id published type), &Map.has_key?(flag_data, &1))
	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/#{note.data["object"]}/i
	)
	end

	test "it accepts an incoming Block", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("type", "Block")
	\|> Map.put("to", [user.ap_id])
	\|> Map.put("cc", [])
	\|> Map.put("object", user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end
	end

	describe "GET /users/:nickname/outbox" do
	setup do
	Mox.stub_with(Pleroma.StaticStubbedConfigMock, Pleroma.Config)
	:ok
	end

	test "it paginates correctly", %{conn: conn} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	outbox_endpoint = user.ap_id <> "/outbox"

	_posts =
	for i <- 0..25 do
	{:ok, activity} = CommonAPI.post(user, %{status: "post #{i}"})
	activity
	end

	result =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint <> "?page=true")
	\|> json_response(200)

	result_ids = Enum.map(result["orderedItems"], fn x -> x["id"] end)
	assert length(result["orderedItems"]) == 20
	assert length(result_ids) == 20
	assert result["next"]
	assert String.starts_with?(result["next"], outbox_endpoint)

	result_next =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result["next"])
	\|> json_response(200)

	result_next_ids = Enum.map(result_next["orderedItems"], fn x -> x["id"] end)
	assert length(result_next["orderedItems"]) == 6
	assert length(result_next_ids) == 6
	refute Enum.find(result_next_ids, fn x -> x in result_ids end)
	refute Enum.find(result_ids, fn x -> x in result_next_ids end)
	assert String.starts_with?(result["id"], outbox_endpoint)

	result_next_again =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result_next["id"])
	\|> json_response(200)

	assert result_next == result_next_again
	end

	test "it returns 200 even if there're no activities", %{conn: conn} do
	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	result = json_response(conn, 200)
	assert outbox_endpoint == result["id"]
	end

	test "it returns a local note activity when authenticated as local user", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user)
	{:ok, note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})
	ap_id = note_activity.data["id"]

	resp =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => [%{"id" => ^ap_id}]} = resp
	end

	test "it does not return a local note activity when unauthenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, _note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})

	resp =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => []} = resp
	end

	test "it does not return a local note activity when C2S API is disabled", %{conn: conn} do
	clear_config([:activitypub, :client_api_enabled], false)
	user = insert(:user)
	reader = insert(:user)
	{:ok, _note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})

	resp =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => []} = resp
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ announce_activity.data["object"]
	end

	test "It returns poll Answers when authenticated", %{conn: conn} do
	poller = insert(:user)
	voter = insert(:user)

	{:ok, activity} =
	CommonAPI.post(poller, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	assert question = Object.normalize(activity, fetch: false)

	{:ok, [activity], _object} = CommonAPI.vote(question, voter, [1])

	assert outbox_get =
	conn
	\|> assign(:user, voter)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(voter.ap_id <> "/outbox?page=true")
	\|> json_response(200)

	assert [answer_outbox] = outbox_get["orderedItems"]
	assert answer_outbox["id"] == activity.data["id"]
	end

	test "it works with authorized fetch forced when authenticated" do
	clear_config([:activitypub, :authorized_fetch_mode], true)

	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	assert json_response(conn, 200)
	end

	test "it fails with authorized fetch forced when unauthenticated", %{conn: conn} do
	clear_config([:activitypub, :authorized_fetch_mode], true)

	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	assert response(conn, 401)
	end
	end

	describe "POST /users/:nickname/outbox (C2S)" do
	setup do: clear_config([:instance, :limit])

	setup do
	[
	activity: %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	}
	]
	end

	test "it rejects posts from other users / unauthenticated users", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	other_user = insert(:user)
	conn = put_req_header(conn, "content-type", "application/activity+json")

	conn
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)

	conn
	\|> assign(:user, other_user)
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)
	end

	test "it inserts an incoming create activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])
	assert result["object"]
	assert %Object{data: object} = Object.normalize(result["object"], fetch: false)
	assert object["content"] == activity["object"]["content"]
	end

	test "it rejects anything beyond 'Note' creations", %{conn: conn, activity: activity} do
	user = insert(:user)

	activity =
	activity
	\|> put_in(["object", "type"], "Benis")

	_result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)
	end

	test "it inserts an incoming sensitive activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	object = Map.put(activity["object"], "sensitive", true)
	activity = Map.put(activity, "object", object)

	response =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(response["id"])
	assert response["object"]
	assert %Object{data: response_object} = Object.normalize(response["object"], fetch: false)
	assert response_object["sensitive"] == true
	assert response_object["content"] == activity["object"]["content"]

	representation =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(response["id"])
	\|> json_response(200)

	assert representation["object"]["sensitive"] == true
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn, activity: activity} do
	user = insert(:user)
	activity = Map.put(activity, "type", "BadType")

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	"type" => "Delete",
	"object" => %{
	"id" => note_object.data["id"]
	}
	}

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it rejects update activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data = %{
	type: "Update",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	assert note_object == Object.normalize(note_activity, fetch: false)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end

	test "it doesn't spreads faulty attributedTo or actor fields", %{
	conn: conn,
	activity: activity
	} do
	reimu = insert(:user, nickname: "reimu")
	cirno = insert(:user, nickname: "cirno")

	assert reimu.ap_id
	assert cirno.ap_id

	activity =
	activity
	\|> put_in(["object", "actor"], reimu.ap_id)
	\|> put_in(["object", "attributedTo"], reimu.ap_id)
	\|> put_in(["actor"], reimu.ap_id)
	\|> put_in(["attributedTo"], reimu.ap_id)

	_reimu_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reimu.nickname}/outbox", activity)
	\|> json_response(403)

	cirno_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{cirno.nickname}/outbox", activity)
	\|> json_response(201)

	assert cirno_outbox["attributedTo"] == nil
	assert cirno_outbox["actor"] == cirno.ap_id

	assert cirno_object = Object.normalize(cirno_outbox["object"], fetch: false)
	assert cirno_object.data["actor"] == cirno.ap_id
	assert cirno_object.data["attributedTo"] == cirno.ap_id
	end

	test "Character limitation", %{conn: conn, activity: activity} do
	clear_config([:instance, :limit], 5)
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)

	assert result == "Character limit (5 characters) exceeded, contains 11 characters"
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/followers")
	\|> json_response(404)
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/following")
	\|> json_response(404)
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user_two)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_followers: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{other_user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_followers: true)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additional ActivityPub C2S endpoints" do
	test "GET /api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

	assert UserView.render("user.json", %{user: user}) == json_response(conn, 200)

	conn
	\|> get("/api/ap/whoami")
	\|> json_response(403)
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	test "POST /api/ap/upload_media", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	object =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(:created)

	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	assert [%{"href" => object_href, "mediaType" => object_mediatype}] = object["url"]
	assert is_binary(object_href)
	assert object_mediatype == "image/jpeg"
	assert String.ends_with?(object_href, ".jpg")

	activity_request = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test, attachment",
	"attachment" => [object],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	}

	activity_response =
	conn
	\|> assign(:user, user)
	\|> post("/users/#{user.nickname}/outbox", activity_request)
	\|> json_response(:created)

	assert activity_response["id"]
	assert activity_response["object"]
	assert activity_response["actor"] == user.ap_id

	assert %Object{data: %{"attachment" => [attachment]}} =
	Object.normalize(activity_response["object"], fetch: false)

	assert attachment["type"] == "Document"
	assert attachment["name"] == desc

	assert [
	%{
	"href" => ^object_href,
	"type" => "Link",
	"mediaType" => ^object_mediatype
	}
	] = attachment["url"]

	# Fails if unauthenticated
	conn
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(403)
	end

	test "they don't work when C2S API is disabled", %{conn: conn} do
	clear_config([:activitypub, :client_api_enabled], false)

	user = insert(:user)

	assert conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")
	\|> response(403)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	assert conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> response(403)
	end
	end

	test "pinned collection", %{conn: conn} do
	clear_config([:instance, :max_pinned_statuses], 2)
	user = insert(:user)
	objects = insert_list(2, :note, user: user)

	Enum.reduce(objects, user, fn %{data: %{"id" => object_id}}, user ->
	{:ok, updated} = User.add_pinned_object_id(user, object_id)
	updated
	end)

	%{nickname: nickname, featured_address: featured_address, pinned_objects: pinned_objects} =
	refresh_record(user)

	%{"id" => ^featured_address, "orderedItems" => items, "totalItems" => 2} =
	conn
	\|> get("/users/#{nickname}/collections/featured")
	\|> json_response(200)

	object_ids = Enum.map(items, & &1["id"])

	assert Enum.all?(pinned_objects, fn {obj_id, _} ->
	obj_id in object_ids
	end)
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/config_controller_test.exs b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	index dc12155f5..e12115ea1 100644
	--- a/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1477 +1,1476 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.ConfigDB

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

	test "when configuration from database is off", %{conn: conn} do
	clear_config(:configurable_from_database, false)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response_and_validate_schema(conn, 400) ==
	%{
	"error" => "You must enable configurable_from_database in your config file."
	}
	end

	test "with settings only in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config?only_db=true")

	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => key1,
	"value" => _
	},
	%{
	"group" => ":pleroma",
	"key" => key2,
	"value" => _
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert key1 == inspect(config1.key)
	assert key2 == inspect(config2.key)
	end

	test "db is added to settings that are in db", %{conn: conn} do
	_config = insert(:config, key: ":instance", value: [name: "Some name"])

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	[instance_config] =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key == ":instance"
	end)

	assert instance_config["db"] == [":name"]
	end

	test "merged default setting with db settings", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	config3 =
	insert(:config,
	value: [k1: :v1, k2: :v2]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert length(configs) > 3

	saved_configs = [config1, config2, config3]
	keys = Enum.map(saved_configs, &inspect(&1.key))

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	\|> Keyword.keys()
	\|> ConfigDB.to_json_types()

	keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))

	values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))

	mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	db = MapSet.new(db)
	assert MapSet.subset?(db, mapset_keys)

	assert value in values
	end)
	end

	test "subkeys with full update right merge", %{conn: conn} do
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	vals =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [":emoji", ":assets"]
	end)

	emoji = Enum.find(vals, fn %{"key" => key} -> key == ":emoji" end)
	assets = Enum.find(vals, fn %{"key" => key} -> key == ":assets" end)

	emoji_val = ConfigDB.to_elixir_types(emoji["value"])
	assets_val = ConfigDB.to_elixir_types(assets["value"])

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	build_conn()
	\|> get("/api/pleroma/admin/config?admin_token=password123")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "POST /api/pleroma/admin/config with configdb disabled", %{conn: conn} do
	clear_config(:configurable_from_database, false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => []})

	assert json_response_and_validate_schema(conn, 400) ==
	%{"error" => "You must enable configurable_from_database in your config file."}
	end

	describe "POST /api/pleroma/admin/config" do
	setup do
	http = Application.get_env(:pleroma, :http)

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	Application.put_env(:pleroma, :http, http)
	Application.put_env(:tesla, :adapter, Tesla.Mock)
	Restarter.Pleroma.refresh()
	end)
	end

	setup do: clear_config(:configurable_from_database, true)

	test "create new config setting in db", %{conn: conn} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: ":pleroma",
	key: ":key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: ":pleroma",
	key: ":key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: ":pleroma",
	key: ":key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: ":idna",
	key: ":key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => "value1",
	"db" => [":key1"]
	},
	%{
	"group" => ":ueberauth",
	"key" => "Ueberauth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
	"db" => [":consumer_secret"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	},
	"db" => [":key2"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	],
	"db" => [":key3"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
	"db" => [":key4"]
	},
	%{
	"group" => ":idna",
	"key" => ":key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
	"db" => [":key5"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	test "save configs setting without explicit key", %{conn: conn} do
	adapter = Application.get_env(:http, :adapter)
	send_user_agent = Application.get_env(:http, :send_user_agent)
	user_agent = Application.get_env(:http, :user_agent)

	on_exit(fn ->
	Application.put_env(:http, :adapter, adapter)
	Application.put_env(:http, :send_user_agent, send_user_agent)
	Application.put_env(:http, :user_agent, user_agent)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":http",
	key: ":adapter",
	value: [":someval"]
	},
	%{
	group: ":http",
	key: ":send_user_agent",
	value: true
	},
	%{
	group: ":http",
	key: ":user_agent",
	value: [":default"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":http",
	"key" => ":adapter",
	"value" => [":someval"],
	"db" => [":adapter"]
	},
	%{
	"group" => ":http",
	"key" => ":send_user_agent",
	"value" => true,
	"db" => [":send_user_agent"]
	},
	%{
	"group" => ":http",
	"key" => ":user_agent",
	"value" => [":default"],
	"db" => [":user_agent"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:http, :adapter) == [:someval]
	assert Application.get_env(:http, :send_user_agent) == true
	assert Application.get_env(:http, :user_agent) == [:default]
	end

	test "saving config with partial update", %{conn: conn} do
	insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key2", 2]},
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key1", ":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving config which need pleroma reboot", %{conn: conn} do
	clear_config([:shout, :enabled], true)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":shout", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":shout",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"]

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
	clear_config([:shout, :enabled], true)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":shout", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":shout",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key3"]
	}
	],
	"need_reboot" => true
	}

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "saving config with nested merge", %{conn: conn} do
	insert(:config, key: :key1, value: [key1: 1, key2: [k1: 1, k2: 2]])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":key1",
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k1", 1]},
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	],
	"db" => [":key1", ":key3", ":key2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving special atoms", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	],
	"db" => [":ssl_options"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == [
	ssl_options: [versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]]
	]
	end

	test "saving full setting if value is not keyword", %{conn: conn} do
	insert(:config,
	group: :tesla,
	key: :adapter,
	value: Tesla.Adapter.Hackey
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":tesla", key: ":adapter", value: "Tesla.Adapter.Httpc"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	],
	"need_reboot" => false
	}
	end

	test "update config setting & delete with fallback to default value", %{
	conn: conn,
	admin: admin,
	token: token
	} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	insert(:config, key: :keyaa1)
	insert(:config, key: :keyaa2)

	config3 =
	insert(:config,
	group: :ueberauth,
	key: Ueberauth
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa1", value: "another_value"},
	%{group: ":pleroma", key: ":keyaa2", value: "another_value"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":keyaa2",
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	assert Application.get_env(:ueberauth, Ueberauth) == config3.value

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa2", delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [],
	"need_reboot" => false
	}

	assert Application.get_env(:ueberauth, Ueberauth) == ueberauth
	refute Keyword.has_key?(Application.get_all_env(:pleroma), :keyaa2)
	end

	test "common config example", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	]
	}
	]
	})

	assert Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Plug.Cowboy.Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Plug.Cowboy.Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	],
	"need_reboot" => false
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"},
	"db" => [":key1"]
	}
	],
	"need_reboot" => false
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	],
	"db" => [
	":federator_incoming",
	":federator_outgoing",
	":web_push",
	":mailer",
	":transmogrifier",
	":scheduled_activities",
	":background"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	insert(:config,
	key: :keyaa1,
	value: [subkey1: "val1", subkey2: "val2", subkey3: "val3"]
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":keyaa1",
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}],
	"db" => [":subkey2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "doesn't set keys not in the whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :key1},
	{:pleroma, :key2},
	{:pleroma, Pleroma.Captcha.NotReal},
	{:not_real}
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":pleroma", key: ":key3", value: "value3"},
	%{group: ":pleroma", key: "Pleroma.Web.Endpoint.NotReal", value: "value4"},
	%{group: ":pleroma", key: "Pleroma.Captcha.NotReal", value: "value5"},
	%{group: ":not_real", key: ":anything", value: "value6"}
	]
	})

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end

	test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	- clear_config(Pleroma.Upload.Filter.Mogrify)
	-
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	]
	}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	- assert Config.get(Pleroma.Upload.Filter.Mogrify) == [args: ["auto-orient", "strip"]]
	+ config = Config.get(Pleroma.Upload.Filter.Mogrify)
	+ assert {:args, ["auto-orient", "strip"]} in config

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	]
	}
	]
	})
	\|> json_response(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	- assert Config.get(Pleroma.Upload.Filter.Mogrify) == [
	- args: ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]
	- ]
	+ config = Config.get(Pleroma.Upload.Filter.Mogrify)
	+
	+ assert {:args, ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]} in config
	end

	test "enables the welcome messages", %{conn: conn} do
	clear_config([:welcome])

	params = %{
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => [
	%{
	"tuple" => [
	":direct_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":chat_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":email",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":sender", %{"tuple" => ["pleroma@dev.dev", "Pleroma"]}]},
	%{"tuple" => [":subject", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":html", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":text", "Welcome to <%= instance_name %>!"]}
	]
	]
	}
	]
	}

	refute Pleroma.User.WelcomeEmail.enabled?()
	refute Pleroma.User.WelcomeMessage.enabled?()
	refute Pleroma.User.WelcomeChatMessage.enabled?()

	res =
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)

	assert Pleroma.User.WelcomeEmail.enabled?()
	assert Pleroma.User.WelcomeMessage.enabled?()
	assert Pleroma.User.WelcomeChatMessage.enabled?()

	assert res == %{
	"configs" => [
	%{
	"db" => [":direct_message", ":chat_message", ":email"],
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}
	end

	test "custom instance thumbnail", %{conn: conn} do
	clear_config([:instance])

	params = %{
	"group" => ":pleroma",
	"key" => ":instance",
	"value" => [
	%{
	"tuple" => [
	":instance_thumbnail",
	"https://example.com/media/new_thumbnail.jpg"
	]
	}
	]
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200) ==
	%{
	"configs" => [
	%{
	"db" => [":instance_thumbnail"],
	"group" => ":pleroma",
	"key" => ":instance",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}

	assert conn
	\|> get("/api/v1/instance")
	\|> json_response_and_validate_schema(200)
	\|> Map.take(["thumbnail"]) ==
	%{"thumbnail" => "https://example.com/media/new_thumbnail.jpg"}
	end

	test "Concurrent Limiter", %{conn: conn} do
	clear_config([ConcurrentLimiter])

	params = %{
	"group" => ":pleroma",
	"key" => "ConcurrentLimiter",
	"value" => [
	%{
	"tuple" => [
	"Pleroma.Web.RichMedia.Helpers",
	[
	%{"tuple" => [":max_running", 6]},
	%{"tuple" => [":max_waiting", 6]}
	]
	]
	},
	%{
	"tuple" => [
	"Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy",
	[
	%{"tuple" => [":max_running", 7]},
	%{"tuple" => [":max_waiting", 7]}
	]
	]
	}
	]
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "GET /api/pleroma/admin/config/descriptions" do
	test "structure", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response_and_validate_schema(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end

	test "filters by database configuration whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :instance},
	{:pleroma, :activitypub},
	{:pleroma, Pleroma.Upload}
	])

	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 3

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 3

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	assert web_endpoint["children"]
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/user_controller_test.exs b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	index c8495c477..0e5650285 100644
	--- a/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	@@ -1,1075 +1,1075 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.UserControllerTest do
	use Pleroma.Web.ConnCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.HTML
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	:ok
	end

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:instance, :admin_privileges], [:users_read])
	clear_config([:admin_token], "password123")

	user = insert(:user)

	conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")

	assert json_response_and_validate_schema(conn, 200)
	end

	describe "DELETE /api/pleroma/admin/users" do
	test "single user", %{admin: admin, conn: conn} do
	clear_config([:instance, :federating], true)
	clear_config([:instance, :admin_privileges], [:users_delete])

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	banner: %{"url" => [%{"href" => "https://somebanner"}]},
	bio: "Hello world!",
	name: "A guy"
	)

	# Create some activities to check they got deleted later
	follower = insert(:user)
	{:ok, _} = CommonAPI.post(user, %{status: "test"})
	{:ok, _, _, _} = CommonAPI.follow(follower, user)
	{:ok, _, _, _} = CommonAPI.follow(user, follower)
	user = Repo.get(User, user.id)
	assert user.note_count == 1
	assert user.follower_count == 1
	assert user.following_count == 1
	assert user.is_active

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end,
	perform: fn _, _ -> nil end do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")

	ObanHelpers.perform_all()

	refute User.get_by_nickname(user.nickname).is_active

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user.nickname}"

	assert json_response_and_validate_schema(conn, 200) == [user.nickname]

	user = Repo.get(User, user.id)
	refute user.is_active

	assert user.avatar == %{}
	assert user.banner == %{}
	assert user.note_count == 0
	assert user.follower_count == 0
	assert user.following_count == 0
	assert user.bio == ""
	assert user.name == nil

	assert called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "multiple users", %{admin: admin, conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_delete])

	user_one = insert(:user)
	user_two = insert(:user)

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/admin/users", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})
	\|> json_response_and_validate_schema(200)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"

	assert response -- [user_one.nickname, user_two.nickname] == []
	end

	test "Needs privileged role", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=nickname")

	assert json_response(response, :forbidden)
	end
	end

	describe "/api/pleroma/admin/users" do
	test "Create", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	},
	%{
	"nickname" => "lain2",
	"email" => "lain2@example.org",
	"password" => "test"
	}
	]
	})
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(&Map.get(&1, "type"))

	assert response == ["success", "success"]

	log_entry = Repo.one(ModerationLog)

	assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
	end

	test "Cannot create user with existing email", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	}
	]
	end

	test "Cannot create user with existing nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => user.nickname,
	"email" => "someuser@plerama.social",
	"password" => "test"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => "someuser@plerama.social",
	"nickname" => user.nickname
	},
	"error" => "nickname has already been taken",
	"type" => "error"
	}
	]
	end

	test "Multiple user creation works in transaction", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "newuser",
	"email" => "newuser@pleroma.social",
	"password" => "test"
	},
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	},
	%{
	"code" => 409,
	"data" => %{
	"email" => "newuser@pleroma.social",
	"nickname" => "newuser"
	},
	"error" => "",
	"type" => "error"
	}
	]

	assert User.get_by_nickname("newuser") === nil
	end
	end

	describe "GET /api/pleroma/admin/users/:nickname" do
	setup do
	clear_config([:instance, :admin_privileges], [:users_read])
	end

	test "returns 403 if not privileged with :users_read", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	conn = get(conn, "/api/pleroma/admin/users/user.nickname")

	assert json_response(conn, :forbidden)
	end

	test "Show", %{conn: conn} do
	user = insert(:user)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	assert user_response(user) == json_response_and_validate_schema(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	user = build(:user)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	assert %{"error" => "Not found"} == json_response_and_validate_schema(conn, 404)
	end

	test "requires admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response_and_validate_schema(conn, 200)
	end

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response_and_validate_schema(conn, :forbidden)
	end
	end
	end

	describe "/api/pleroma/admin/users/follow" do
	test "allows to force-follow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/users/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
	end
	end

	describe "/api/pleroma/admin/users/unfollow" do
	test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/users/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
	end
	end

	describe "GET /api/pleroma/admin/users" do
	setup do
	clear_config([:instance, :admin_privileges], [:users_read])
	end

	test "returns 403 if not privileged with :users_read", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	conn = get(conn, "/api/pleroma/admin/users?page=1")

	assert json_response(conn, :forbidden)
	end

	test "renders users array for the first page", %{conn: conn, admin: admin} do
	user = insert(:user, local: false, tags: ["foo", "bar"])
	user2 = insert(:user, is_approved: false, registration_reason: "I'm a chill dude")

	conn = get(conn, "/api/pleroma/admin/users?page=1")

	users = [
	user_response(
	user2,
	%{
	"local" => true,
	"is_approved" => false,
	"registration_reason" => "I'm a chill dude",
	"actor_type" => "Person"
	}
	),
	user_response(user, %{"local" => false, "tags" => ["foo", "bar"]}),
	user_response(
	admin,
	%{"roles" => %{"admin" => true, "moderator" => false}}
	)
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "pagination works correctly with service users", %{conn: conn} do
	service1 = User.get_or_create_service_actor_by_ap_id(Endpoint.url() <> "/meido", "meido")

	insert_list(25, :user)

	assert %{"count" => 26, "page_size" => 10, "users" => users1} =
	conn
	\|> get("/api/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
	\|> json_response_and_validate_schema(200)

	assert Enum.count(users1) == 10
	assert service1 not in users1

	assert %{"count" => 26, "page_size" => 10, "users" => users2} =
	conn
	\|> get("/api/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
	\|> json_response_and_validate_schema(200)

	assert Enum.count(users2) == 10
	assert service1 not in users2

	assert %{"count" => 26, "page_size" => 10, "users" => users3} =
	conn
	\|> get("/api/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
	\|> json_response_and_validate_schema(200)

	assert Enum.count(users3) == 6
	assert service1 not in users3
	end

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?page=2")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	conn = get(conn, "/api/pleroma/admin/users?query=bo")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user, %{"local" => true})]
	}
	end

	test "search by domain", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=domain.com")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?name=display")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response_and_validate_schema(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [user_response(user2)]
	}

	conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response_and_validate_schema(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [user_response(user)]
	}
	end

	test "only local users" do
	admin = insert(:user, is_admin: true, nickname: "john")
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?query=bo&filters=local")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "only local users with no query", %{conn: conn, admin: old_admin} do
	admin = insert(:user, is_admin: true, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn = get(conn, "/api/pleroma/admin/users?filters=local")

	users = [
	user_response(user),
	user_response(admin, %{
	"roles" => %{"admin" => true, "moderator" => false}
	}),
	user_response(old_admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	})
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "only unconfirmed users", %{conn: conn} do
	sad_user = insert(:user, nickname: "sadboy", is_confirmed: false)
	old_user = insert(:user, nickname: "oldboy", is_confirmed: false)

	insert(:user, nickname: "happyboy", is_approved: true)
	insert(:user, is_confirmed: true)

	result =
	conn
	\|> get("/api/pleroma/admin/users?filters=unconfirmed")
	\|> json_response_and_validate_schema(200)

	users =
	Enum.map([old_user, sad_user], fn user ->
	user_response(user, %{
	"is_confirmed" => false,
	"is_approved" => true
	})
	end)

	assert result == %{"count" => 2, "page_size" => 50, "users" => users}
	end

	test "only unapproved users", %{conn: conn} do
	user =
	insert(:user,
	nickname: "sadboy",
	is_approved: false,
	registration_reason: "Plz let me in!"
	)

	insert(:user, nickname: "happyboy", is_approved: true)

	conn = get(conn, "/api/pleroma/admin/users?filters=need_approval")

	users = [
	user_response(
	user,
	%{"is_approved" => false, "registration_reason" => "Plz let me in!"}
	)
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only admins", %{conn: conn, admin: admin} do
	second_admin = insert(:user, is_admin: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")

	users = [
	user_response(second_admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	}),
	user_response(admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	})
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only moderators", %{conn: conn} do
	moderator = insert(:user, is_moderator: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	user_response(moderator, %{
	"is_active" => true,
	"roles" => %{"admin" => false, "moderator" => true}
	})
	]
	}
	end

	test "load users with actor_type is Person", %{admin: admin, conn: conn} do
	insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")

	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> get(user_path(conn, :index), %{actor_types: ["Person"]})
	\|> json_response_and_validate_schema(200)

	users = [
	user_response(user2),
	user_response(user1),
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]

	assert response == %{"count" => 3, "page_size" => 50, "users" => users}
	end

	test "load users with actor_type is Person and Service", %{admin: admin, conn: conn} do
	user_service = insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")

	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> get(user_path(conn, :index), %{actor_types: ["Person", "Service"]})
	\|> json_response_and_validate_schema(200)

	users = [
	user_response(user2),
	user_response(user1),
	user_response(user_service, %{"actor_type" => "Service"}),
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]

	assert response == %{"count" => 4, "page_size" => 50, "users" => users}
	end

	test "load users with actor_type is Service", %{conn: conn} do
	user_service = insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")
	insert(:user)
	insert(:user)

	response =
	conn
	\|> get(user_path(conn, :index), %{actor_types: ["Service"]})
	\|> json_response_and_validate_schema(200)

	users = [user_response(user_service, %{"actor_type" => "Service"})]

	assert response == %{"count" => 1, "page_size" => 50, "users" => users}
	end

	test "load users with tags list", %{conn: conn} do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")

	users = [
	user_response(user2, %{"tags" => ["second"]}),
	user_response(user1, %{"tags" => ["first"]})
	]

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "`active` filters out users pending approval", %{token: token} do
	insert(:user, is_approved: false)
	%{id: user_id} = insert(:user, is_approved: true)
	%{id: admin_id} = token.user

	conn =
	build_conn()
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?filters=active")

	assert %{
	"count" => 2,
	"page_size" => 50,
	"users" => [
	%{"id" => ^user_id},
	%{"id" => ^admin_id}
	]
	} = json_response_and_validate_schema(conn, 200)
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob", local: false, is_active: false)

	insert(:user, nickname: "ken", local: true, is_active: false)
	insert(:user, nickname: "bobb", local: false, is_active: true)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?filters=deactivated,external")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "it omits relay user", %{admin: admin, conn: conn} do
	assert %User{} = Relay.get_actor()

	conn = get(conn, "/api/pleroma/admin/users")

	assert json_response_and_validate_schema(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_invites])

	user_one = insert(:user, is_approved: false)
	user_two = insert(:user, is_approved: false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/approve",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response_and_validate_schema(conn, 200)
	assert Enum.map(response["users"], & &1["is_approved"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} approved users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/approve returns 403 if not privileged with :users_manage_invites",
	%{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/approve",
	%{nicknames: ["user_one.nickname", "user_two.nickname"]}
	)

	assert json_response(conn, :forbidden)
	end

	test "PATCH /api/pleroma/admin/users/suggest", %{admin: admin, conn: conn} do
	user1 = insert(:user, is_suggested: false)
	user2 = insert(:user, is_suggested: false)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/suggest",
	%{nicknames: [user1.nickname, user2.nickname]}
	)
	\|> json_response_and_validate_schema(200)

	assert Enum.map(response["users"], & &1["is_suggested"]) == [true, true]
	[user1, user2] = Repo.reload!([user1, user2])

	assert user1.is_suggested
	assert user2.is_suggested

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} added suggested users: @#{user1.nickname}, @#{user2.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/unsuggest", %{admin: admin, conn: conn} do
	user1 = insert(:user, is_suggested: true)
	user2 = insert(:user, is_suggested: true)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/unsuggest",
	%{nicknames: [user1.nickname, user2.nickname]}
	)
	\|> json_response_and_validate_schema(200)

	assert Enum.map(response["users"], & &1["is_suggested"]) == [false, false]
	[user1, user2] = Repo.reload!([user1, user2])

	refute user1.is_suggested
	refute user2.is_suggested

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} removed suggested users: @#{user1.nickname}, @#{user2.nickname}"
	end

	describe "user activation" do
	test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_activation_state])

	user_one = insert(:user, is_active: false)
	user_two = insert(:user, is_active: false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/activate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response_and_validate_schema(conn, 200)
	assert Enum.map(response["users"], & &1["is_active"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_activation_state])

	user_one = insert(:user, is_active: true)
	user_two = insert(:user, is_active: true)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/deactivate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response_and_validate_schema(conn, 200)
	assert Enum.map(response["users"], & &1["is_active"]) == [false, false]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation", %{admin: admin, conn: conn} do
	clear_config([:instance, :admin_privileges], [:users_manage_activation_state])

	user = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response_and_validate_schema(conn, 200) ==
	user_response(
	user,
	%{"is_active" => !user.is_active}
	)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user.nickname}"
	end

	test "it requires privileged role :statuses_activation to activate", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/activate",
	%{nicknames: ["user_one.nickname", "user_two.nickname"]}
	)

	assert json_response(conn, :forbidden)
	end

	test "it requires privileged role :statuses_activation to deactivate", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch(
	"/api/pleroma/admin/users/deactivate",
	%{nicknames: ["user_one.nickname", "user_two.nickname"]}
	)

	assert json_response(conn, :forbidden)
	end

	test "it requires privileged role :statuses_activation to toggle activation", %{conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/users/user.nickname/toggle_activation")

	assert json_response(conn, :forbidden)
	end
	end

	defp user_response(user, attrs \\ %{}) do
	%{
	"is_active" => user.is_active,
	"id" => user.id,
	"email" => user.email,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"is_confirmed" => true,
	"is_approved" => true,
	"is_suggested" => false,
	"url" => user.ap_id,
	"registration_reason" => nil,
	"actor_type" => "Person",
	"created_at" => CommonAPI.Utils.to_masto_date(user.inserted_at)
	}
	\|> Map.merge(attrs)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	index 54f6818bd..cd3107f32 100644
	--- a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	@@ -1,2267 +1,2267 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Plugs.SetLocalePlug

	import Pleroma.Factory

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	describe "account fetching" do
	test "works by id" do
	%User{id: user_id} = insert(:user)

	assert %{"id" => ^user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "Can't find user"} =
	build_conn()
	\|> get("/api/v1/accounts/-1")
	\|> json_response_and_validate_schema(404)
	end

	test "relationship field" do
	%{conn: conn, user: user} = oauth_access(["read"])

	other_user = insert(:user)

	response =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert response["id"] == other_user.id
	assert response["pleroma"]["relationship"] == %{}

	assert %{"pleroma" => %{"relationship" => %{"following" => false, "followed_by" => false}}} =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, %{id: other_id}} = User.follow(user, other_user)

	assert %{
	"id" => ^other_id,
	"pleroma" => %{"relationship" => %{"following" => true, "followed_by" => false}}
	} =
	conn
	\|> get("/api/v1/accounts/#{other_id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, _} = User.follow(other_user, user)

	assert %{
	"id" => ^other_id,
	"pleroma" => %{"relationship" => %{"following" => true, "followed_by" => true}}
	} =
	conn
	\|> get("/api/v1/accounts/#{other_id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname" do
	user = insert(:user)

	assert %{"id" => _user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname for remote users" do
	clear_config([:instance, :limit_to_local_content], false)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert %{"id" => _user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "respects limit_to_local_content == :all for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :all)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects limit_to_local_content == :unauthenticated for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)

	user = insert(:user, nickname: "user@example.com", local: false)
	reading_user = insert(:user)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert json_response_and_validate_schema(conn, 404)

	conn =
	build_conn()
	\|> assign(:user, reading_user)
	\|> assign(:token, insert(:oauth_token, user: reading_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == user.id
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	acc_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")
	\|> json_response_and_validate_schema(:ok)

	acc_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")
	\|> json_response_and_validate_schema(:ok)

	acc_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")
	\|> json_response_and_validate_schema(:ok)

	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for internal.fetch actor", %{conn: conn} do
	%User{nickname: "internal.fetch"} = InternalFetchActor.get_actor()

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/internal.fetch")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for deactivated user", %{conn: conn} do
	user = insert(:user, is_active: false)

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(:not_found)
	end
	end

	defp local_and_remote_users do
	local = insert(:user)
	remote = insert(:user, local: false)
	{:ok, local: local, remote: remote}
	end

	describe "user fetching with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user timelines" do
	setup do: oauth_access(["read:statuses"])

	test "works with announces that are just addressed to public", %{conn: conn} do
	user = insert(:user, ap_id: "https://honktest/u/test", local: false)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})

	{:ok, announce, _} =
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://honktest/u/test",
	"id" => "https://honktest/u/test/bonk/1793M7B9MQ48847vdx",
	"object" => post.data["object"],
	"published" => "2019-06-25T19:33:58Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"type" => "Announce"
	}
	\|> ActivityPub.persist(local: false)

	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == announce.id
	end

	test "deactivated user", %{conn: conn} do
	user = insert(:user, is_active: false)

	assert %{"error" => "Can't find user"} ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(:not_found)
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects blocks", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	user_three = insert(:user)

	User.block(user_one, user_two)

	{:ok, activity} = CommonAPI.post(user_two, %{status: "User one sux0rz"})
	{:ok, repeat} = CommonAPI.repeat(activity.id, user_three)

	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Even a blocked user will deliver the full user timeline, there would be
	# no point in looking at a blocked users timeline otherwise
	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Third user's timeline includes the repeat when viewed by unauthenticated user
	resp =
	build_conn()
	\|> get("/api/v1/accounts/#{user_three.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == repeat.id

	# When viewing a third user's timeline, the blocked users' statuses will NOT be shown
	resp = get(conn, "/api/v1/accounts/#{user_three.id}/statuses")

	assert [] == json_response_and_validate_schema(resp, 200)
	end

	test "gets users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, _user_three, _user_one} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	status: "Hi, @#{user_two.nickname}.",
	visibility: "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{status: "private", visibility: "private"})

	# TODO!!!
	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id_one}, %{"id" => id_two}] = resp
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> assign(:token, insert(:oauth_token, user: user_three, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id_one}, %{"id" => id_two}] = resp
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "gets local-only statuses for authenticated users", %{user: _user, conn: conn} do
	user_one = insert(:user)

	{:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!", visibility: "local"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == to_string(activity.id)
	end

	test "gets an users media, excludes reblogs", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])
	other_user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %{id: image_post_id}} = CommonAPI.post(user, %{status: "cofe", media_ids: [media_id]})

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: other_user.ap_id)

	{:ok, %{id: other_image_post_id}} =
	CommonAPI.post(other_user, %{status: "cofe2", media_ids: [media_id]})

	{:ok, _announce} = CommonAPI.repeat(other_image_post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_media=true")

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(build_conn(), "/api/v1/accounts/#{user.id}/statuses?only_media=1")

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
	{:ok, _} = CommonAPI.repeat(post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=1")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "filters user's statuses by a hashtag", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "#hashtag"})
	{:ok, _post} = CommonAPI.post(user, %{status: "hashtag"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "the user views their own timelines and excludes direct messages", %{
	user: user,
	conn: conn
	} do
	{:ok, %{id: public_activity_id}} =
	CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, _direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct")
	assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "muted reactions", %{user: user, conn: conn} do
	user2 = insert(:user)
	User.mute(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user2, "🎅")

	result =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "paginates a user's statuses", %{user: user, conn: conn} do
	{:ok, post_1} = CommonAPI.post(user, %{status: "first post"})
	{:ok, post_2} = CommonAPI.post(user, %{status: "second post"})

	response_1 = get(conn, "/api/v1/accounts/#{user.id}/statuses?limit=1")
	assert [res] = json_response_and_validate_schema(response_1, 200)
	assert res["id"] == post_2.id

	response_2 = get(conn, "/api/v1/accounts/#{user.id}/statuses?limit=1&max_id=#{res["id"]}")
	assert [res] = json_response_and_validate_schema(response_2, 200)
	assert res["id"] == post_1.id

	refute response_1 == response_2
	end
	end

	defp local_and_remote_activities(%{local: local, remote: remote}) do
	insert(:note_activity, user: local)
	insert(:note_activity, user: remote, local: false)

	:ok
	end

	describe "statuses with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "followers" do
	setup do: oauth_access(["read:accounts"])

	test "getting followers", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, %{id: user_id}, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => ^user_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "following with relationship", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, %{id: id}, _} = User.follow(other_user, user)

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{
	"id" => ^id,
	"following" => false,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, _} = User.follow(user, other_user)

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{
	"id" => ^id,
	"following" => true,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "getting followers, hide_followers", %{user: user, conn: conn} do
	other_user = insert(:user, hide_followers: true)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting" do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, pagination", %{user: user, conn: conn} do
	{:ok, %User{id: follower1_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower2_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower3_id}, _user} = :user \|> insert() \|> User.follow(user)

	assert [%{"id" => ^follower3_id}, %{"id" => ^follower2_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get(
	"/api/v1/accounts/#{user.id}/followers?id=#{user.id}&limit=20&max_id=#{follower3_id}"
	)
	\|> json_response_and_validate_schema(200)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3_id}")

	assert [%{"id" => ^follower2_id}] = json_response_and_validate_schema(res_conn, 200)

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{follower2_id}/
	assert link_header =~ ~r/max_id=#{follower2_id}/
	end
	end

	describe "following" do
	setup do: oauth_access(["read:accounts"])

	test "getting following", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "following with relationship", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/following?with_relationships=true")

	id = other_user.id

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{"id" => ^id, "following" => true, "followed_by" => false}
	}
	}
	] = json_response_and_validate_schema(conn, 200)
	end

	test "getting following, hide_follows, other user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, hide_follows, same user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, _other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, pagination", %{user: user, conn: conn} do
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _, _} = User.follow(user, following1)
	{:ok, _, _} = User.follow(user, following2)
	{:ok, _, _} = User.follow(user, following3)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(
	conn,
	"/api/v1/accounts/#{user.id}/following?id=#{user.id}&limit=20&max_id=#{following3.id}"
	)

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(conn, "/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end
	end

	describe "follow/unfollow" do
	setup do: oauth_access(["follow"])

	test "following / unfollowing a user", %{conn: conn} do
	%{id: other_user_id, nickname: other_user_nickname} = insert(:user)

	assert %{"id" => _id, "following" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => _id, "following" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => ^other_user_id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/follows", %{"uri" => other_user_nickname})
	\|> json_response_and_validate_schema(200)
	end

	test "cancelling follow request", %{conn: conn} do
	%{id: other_user_id} = insert(:user, %{is_locked: true})

	assert %{"id" => ^other_user_id, "following" => false, "requested" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(:ok)

	assert %{"id" => ^other_user_id, "following" => false, "requested" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(:ok)
	end

	test "following without reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})

	assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: true})
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: "1"})
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	end

	test "following with reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{followed.id}/follow")

	assert %{"showing_reblogs" => true} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: "0"})
	\|> json_response_and_validate_schema(200)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	end

	test "following with subscription and unsubscribing" do
	%{conn: conn} = oauth_access(["follow"])
	followed = insert(:user)

	assert %{"subscribing" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: true})
	\|> json_response_and_validate_schema(200)

	assert %{"subscribing" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: "1"})
	\|> json_response_and_validate_schema(200)

	assert %{"subscribing" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: false})
	\|> json_response_and_validate_schema(200)
	end

	test "following / unfollowing errors", %{user: user, conn: conn} do
	# self follow
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")

	assert %{"error" => "Can not follow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self unfollow
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self follow via uri
	user = User.get_cached_by_id(user.id)

	assert %{"error" => "Can not follow yourself"} =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => user.nickname})
	\|> json_response_and_validate_schema(400)

	# follow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# follow non existing user via uri
	conn_res =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => "doesntexist"})

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# unfollow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end

	describe "mute/unmute" do
	setup do: oauth_access(["write:mutes"])

	test "with notifications", %{conn: conn} do
	other_user = insert(:user)

	assert %{"id" => _id, "muting" => true, "muting_notifications" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user.id}/mute")
	\|> json_response_and_validate_schema(200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

	test "without notifications", %{conn: conn} do
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"notifications" => "false"})

	assert %{"id" => _id, "muting" => true, "muting_notifications" => false} =
	json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

	test "expiring", %{conn: conn, user: user} do
	other_user = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"duration" => "86400"})

	assert %{"id" => _id, "muting" => true} = json_response_and_validate_schema(conn, 200)

	mute_expires_at = UserRelationship.get_mute_expire_date(user, other_user)

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end

	test "falls back to expires_in", %{conn: conn, user: user} do
	other_user = insert(:user)

	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"expires_in" => "86400"})
	\|> json_response_and_validate_schema(200)

	mute_expires_at = UserRelationship.get_mute_expire_date(user, other_user)

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end
	end

	describe "pinned statuses" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
	%{conn: conn} = oauth_access(["read:statuses"], user: user)

	[conn: conn, user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: %{id: activity_id}} do
	{:ok, _} = CommonAPI.pin(activity_id, user)

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "view pinned private statuses" do
	user = insert(:user)
	reader = insert(:user)

	# Create a private status and pin it
	{:ok, %{id: activity_id} = activity} =
	CommonAPI.post(user, %{status: "psst", visibility: "private"})

	%{data: %{"id" => object_ap_id}} = Object.normalize(activity)
	{:ok, _} = User.add_pinned_object_id(user, object_ap_id)

	%{conn: conn} = oauth_access(["read:statuses"], user: reader)

	# A non-follower can't see the pinned status
	assert [] ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)

	# Follow the user, then the pinned status can be seen
	CommonAPI.follow(user, reader)
	ObanHelpers.perform_all()

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end

	test "blocking / unblocking a user" do
	%{conn: conn} = oauth_access(["follow"])
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response_and_validate_schema(conn, 200)
	end

	describe "create account by app" do
	setup do
	valid_params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	}

	[valid_params: valid_params]
	end

	test "registers and logs in without :account_activation_required / :account_approval_required",
	%{conn: conn} do
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	clear_config([User, :email_blacklist], ["example.org"])

	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true
	}

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", params)

	assert %{"error" => "{\"email\":[\"Invalid email\"]}"} =
	json_response_and_validate_schema(conn, 400)

	clear_config([User, :email_blacklist], [])

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", params)

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => ^scope,
	"token_type" => "Bearer"
	} = json_response_and_validate_schema(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	user = Repo.preload(token_from_db, :user).user

	assert user
	assert user.is_confirmed
	assert user.is_approved
	end

	test "registers but does not log in with :account_activation_required", %{conn: conn} do
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :account_approval_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true
	})

	response = json_response_and_validate_schema(conn, 200)
	assert %{"identifier" => "missing_confirmed_email"} = response
	refute response["access_token"]
	refute response["token_type"]

	user = Repo.get_by(User, email: "lain@example.org")
	refute user.is_confirmed
	end

	test "registers but does not log in with :account_approval_required", %{conn: conn} do
	clear_config([:instance, :account_approval_required], true)
	clear_config([:instance, :account_activation_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true,
	reason: "I'm a cool dude, bro"
	})

	response = json_response_and_validate_schema(conn, 200)
	assert %{"identifier" => "awaiting_approval"} = response
	refute response["access_token"]
	refute response["token_type"]

	user = Repo.get_by(User, email: "lain@example.org")

	refute user.is_approved
	assert user.registration_reason == "I'm a cool dude, bro"
	end

	test "returns error when user already registered", %{conn: conn, valid_params: valid_params} do
	_user = insert(:user, email: "lain@example.org")
	app_token = insert(:oauth_token, user: nil)

	res =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts", valid_params)

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"email\":[\"has already been taken\"]}"
	}
	end

	test "returns bad_request if missing required params", %{
	conn: conn,
	valid_params: valid_params
	} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")

	res = post(conn, "/api/v1/accounts", valid_params)
	assert json_response_and_validate_schema(res, 200)

	[{127, 0, 0, 1}, {127, 0, 0, 2}, {127, 0, 0, 3}, {127, 0, 0, 4}]
	\|> Stream.zip(Map.delete(valid_params, :email))
	\|> Enum.each(fn {ip, {attr, _}} ->
	res =
	conn
	\|> Map.put(:remote_ip, ip)
	\|> post("/api/v1/accounts", Map.delete(valid_params, attr))
	\|> json_response_and_validate_schema(400)

	assert res == %{
	"error" => "Missing field: #{attr}.",
	"errors" => [
	%{
	"message" => "Missing field: #{attr}",
	"source" => %{"pointer" => "/#{attr}"},
	"title" => "Invalid value"
	}
	]
	}
	end)
	end

	test "returns bad_request if missing email params when :account_activation_required is enabled",
	%{conn: conn, valid_params: valid_params} do
	clear_config([:instance, :account_activation_required], true)

	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")

	res =
	conn
	\|> Map.put(:remote_ip, {127, 0, 0, 5})
	\|> post("/api/v1/accounts", Map.delete(valid_params, :email))

	assert json_response_and_validate_schema(res, 400) ==
	%{"error" => "Missing parameter: email"}

	res =
	conn
	\|> Map.put(:remote_ip, {127, 0, 0, 6})
	\|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"email\":[\"can't be blank\"]}"
	}
	end

	test "allow registration without an email", %{conn: conn, valid_params: valid_params} do
	app_token = insert(:oauth_token, user: nil)
	conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)

	res =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> Map.put(:remote_ip, {127, 0, 0, 7})
	\|> post("/api/v1/accounts", Map.delete(valid_params, :email))

	assert json_response_and_validate_schema(res, 200)
	end

	test "allow registration with an empty email", %{conn: conn, valid_params: valid_params} do
	app_token = insert(:oauth_token, user: nil)
	conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)

	res =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> Map.put(:remote_ip, {127, 0, 0, 8})
	\|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))

	assert json_response_and_validate_schema(res, 200)
	end

	test "returns forbidden if token is invalid", %{conn: conn, valid_params: valid_params} do
	res =
	conn
	\|> put_req_header("authorization", "Bearer " <> "invalid-token")
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts", valid_params)

	assert json_response_and_validate_schema(res, 403) == %{"error" => "Invalid credentials"}
	end

	test "registration from trusted app" do
	clear_config([Pleroma.Captcha, :enabled], true)
	app = insert(:oauth_app, trusted: true, scopes: ["read", "write", "follow", "push"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "client_credentials",
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "token_type" => "Bearer"} = json_response(conn, 200)

	response =
	build_conn()
	\|> Plug.Conn.put_req_header("authorization", "Bearer " <> token)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts", %{
	nickname: "nickname",
	agreement: true,
	email: "email@example.com",
	fullname: "Lain",
	username: "Lain",
	password: "some_password",
	confirm: "some_password"
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"access_token" => access_token,
	"created_at" => _,
	"scope" => "read write follow push",
	"token_type" => "Bearer"
	} = response

	response =
	build_conn()
	\|> Plug.Conn.put_req_header("authorization", "Bearer " <> access_token)
	\|> get("/api/v1/accounts/verify_credentials")
	\|> json_response_and_validate_schema(200)

	assert %{
	"acct" => "Lain",
	"bot" => false,
	"display_name" => "Lain",
	"follow_requests_count" => 0,
	"followers_count" => 0,
	"following_count" => 0,
	"locked" => false,
	"note" => "",
	"source" => %{
	"fields" => [],
	"note" => "",
	"pleroma" => %{
	"actor_type" => "Person",
	"discoverable" => false,
	"no_rich_text" => false,
	"show_role" => true
	},
	"privacy" => "public",
	"sensitive" => false
	},
	"statuses_count" => 0,
	"username" => "Lain"
	} = response
	end
	end

	describe "create account by app / rate limit" do
	setup do: clear_config([:rate_limit, :app_account_creation], {10_000, 2})

	test "respects rate limit setting", %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> Map.put(:remote_ip, {15, 15, 15, 15})
	\|> put_req_header("content-type", "multipart/form-data")

	for i <- 1..2 do
	conn =
	conn
	\|> post("/api/v1/accounts", %{
	username: "#{i}lain",
	email: "#{i}lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => _scope,
	"token_type" => "Bearer"
	} = json_response_and_validate_schema(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	token_from_db = Repo.preload(token_from_db, :user)
	assert token_from_db.user
	end

	conn =
	post(conn, "/api/v1/accounts", %{
	username: "6lain",
	email: "6lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	assert json_response_and_validate_schema(conn, :too_many_requests) == %{
	"error" => "Throttled"
	}
	end
	end

	describe "create account with enabled captcha" do
	setup %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")

	[conn: conn]
	end

	setup do: clear_config([Pleroma.Captcha, :enabled], true)

	test "creates an account and returns 200 if captcha is valid", %{conn: conn} do
	%{token: token, answer_data: answer_data} = Pleroma.Captcha.new()

	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: Pleroma.Captcha.Mock.solution(),
	captcha_token: token,
	captcha_answer_data: answer_data
	}

	assert %{
	"access_token" => access_token,
	"created_at" => _,
	"scope" => "read",
	"token_type" => "Bearer"
	} =
	conn
	\|> post("/api/v1/accounts", params)
	\|> json_response_and_validate_schema(:ok)

	assert Token \|> Repo.get_by(token: access_token) \|> Repo.preload(:user) \|> Map.get(:user)
	end

	test "returns 400 if any captcha field is not provided", %{conn: conn} do
	captcha_fields = [:captcha_solution, :captcha_token, :captcha_answer_data]

	valid_params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: "xx",
	captcha_token: "xx",
	captcha_answer_data: "xx"
	}

	for field <- captcha_fields do
	expected = %{
	"error" => "{\"captcha\":[\"Invalid CAPTCHA (Missing parameter: #{field})\"]}"
	}

	assert expected ==
	conn
	\|> post("/api/v1/accounts", Map.delete(valid_params, field))
	\|> json_response_and_validate_schema(:bad_request)
	end
	end

	test "returns an error if captcha is invalid", %{conn: conn} do
	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: "cofe",
	captcha_token: "cofe",
	captcha_answer_data: "cofe"
	}

	assert %{"error" => "{\"captcha\":[\"Invalid answer data\"]}"} ==
	conn
	\|> post("/api/v1/accounts", params)
	\|> json_response_and_validate_schema(:bad_request)
	end
	end

	describe "create account with required birth date" do
	setup %{conn: conn} do
	clear_config([:instance, :birthday_required], true)
	clear_config([:instance, :birthday_min_age], 18 * 365)

	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")

	[conn: conn]
	end

	test "creates an account if provided valid birth date", %{conn: conn} do
	birthday =
	Date.utc_today()
	\|> Date.add(-19 * 365)
	\|> Date.to_string()

	params = %{
	username: "mkljczk",
	email: "mkljczk@example.org",
	password: "dupa.8",
	agreement: true,
	birthday: birthday
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)
	end

	test "returns an error if missing birth date", %{conn: conn} do
	params = %{
	username: "mkljczk",
	email: "mkljczk@example.org",
	password: "dupa.8",
	agreement: true
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"birthday\":[\"can't be blank\"]}"
	}
	end
	end

	describe "create account with language" do
	setup %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_cookie(SetLocalePlug.frontend_language_cookie_name(), "zh-Hans")
	\|> SetLocalePlug.call([])

	[conn: conn]
	end

	test "creates an account with language parameter", %{conn: conn} do
	params = %{
	username: "foo",
	email: "foo@example.org",
	password: "dupa.8",
	agreement: true,
	language: "ru"
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "ru"} = Pleroma.User.get_by_nickname("foo")
	end

	test "language parameter should be normalized", %{conn: conn} do
	params = %{
	username: "foo",
	email: "foo@example.org",
	password: "dupa.8",
	agreement: true,
	language: "ru-RU"
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "ru_RU"} = Pleroma.User.get_by_nickname("foo")
	end

	test "creating an account without language parameter should fallback to cookie/header language",
	%{conn: conn} do
	params = %{
	username: "foo2",
	email: "foo2@example.org",
	password: "dupa.8",
	agreement: true
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "zh_Hans"} = Pleroma.User.get_by_nickname("foo2")
	end
	end

	describe "GET /api/v1/accounts/:id/lists - account_lists" do
	test "returns lists to which the account belongs" do
	%{user: user, conn: conn} = oauth_access(["read:lists"])
	other_user = insert(:user)
	assert {:ok, %Pleroma.List{id: _list_id} = list} = Pleroma.List.create("Test List", user)
	{:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)

	assert [%{"id" => _list_id, "title" => "Test List"}] =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/lists")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "verify_credentials" do
	test "verify_credentials" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	[notification \| _] =
	insert_list(7, :notification, user: user, activity: insert(:note_activity))

	Pleroma.Notification.set_read_up_to(user, notification.id)
	conn = get(conn, "/api/v1/accounts/verify_credentials")

	response = json_response_and_validate_schema(conn, 200)

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = response
	assert response["pleroma"]["chat_token"]
	assert response["pleroma"]["unread_notifications_count"] == 6
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted" do
	user = insert(:user, default_scope: "unlisted")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end

	test "locked accounts" do
	user = insert(:user, default_scope: "private")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end
	end

	describe "user relationships" do
	setup do: oauth_access(["read:follows"])

	test "returns the relationships for the current user", %{user: user, conn: conn} do
	%{id: other_user_id} = other_user = insert(:user)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id[]=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns an empty list on a bad request", %{conn: conn} do
	conn = get(conn, "/api/v1/accounts/relationships", %{})

	assert [] = json_response_and_validate_schema(conn, 200)
	end
	end

	test "getting a list of mutes" do
	%{user: user, conn: conn} = oauth_access(["read:mutes"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user1)
	{:ok, _user_relationships} = User.mute(user, other_user2)
	{:ok, _user_relationships} = User.mute(user, other_user3)

	result =
	conn
	\|> get("/api/v1/mutes")
	\|> json_response_and_validate_schema(200)

	assert [id3, id2, id1] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> get("/api/v1/mutes?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result
	end

	test "list of mutes with with_relationships parameter" do
	%{user: user, conn: conn} = oauth_access(["read:mutes"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _, _} = User.follow(other_user1, user)
	{:ok, _, _} = User.follow(other_user2, user)
	{:ok, _, _} = User.follow(other_user3, user)

	{:ok, _} = User.mute(user, other_user1)
	{:ok, _} = User.mute(user, other_user2)
	{:ok, _} = User.mute(user, other_user3)

	assert [
	%{
	"id" => ^id3,
	"pleroma" => %{"relationship" => %{"muting" => true, "followed_by" => true}}
	},
	%{
	"id" => ^id2,
	"pleroma" => %{"relationship" => %{"muting" => true, "followed_by" => true}}
	},
	%{
	"id" => ^id1,
	"pleroma" => %{"relationship" => %{"muting" => true, "followed_by" => true}}
	}
	] =
	conn
	\|> get("/api/v1/mutes?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "getting a list of blocks" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationship} = User.block(user, other_user1)
	{:ok, _user_relationship} = User.block(user, other_user3)
	{:ok, _user_relationship} = User.block(user, other_user2)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")
	\|> json_response_and_validate_schema(200)

	assert [id3, id2, id1] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	conn_res =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=2")

	next_url =
	~r{<.+?(?<link>/api[^>]+)>; rel=\"next\"}
	\|> Regex.named_captures(get_resp_header(conn_res, "link") \|> Enum.at(0))
	\|> Map.get("link")

	result =
	conn_res
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get(next_url)
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] = result
	end

	test "list of blocks with with_relationships parameter" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _, _} = User.follow(other_user1, user)
	{:ok, _, _} = User.follow(other_user2, user)
	{:ok, _, _} = User.follow(other_user3, user)

	{:ok, _} = User.block(user, other_user1)
	{:ok, _} = User.block(user, other_user2)
	{:ok, _} = User.block(user, other_user3)

	assert [
	%{
	"id" => ^id3,
	"pleroma" => %{"relationship" => %{"blocking" => true, "followed_by" => false}}
	},
	%{
	"id" => ^id2,
	"pleroma" => %{"relationship" => %{"blocking" => true, "followed_by" => false}}
	},
	%{
	"id" => ^id1,
	"pleroma" => %{"relationship" => %{"blocking" => true, "followed_by" => false}}
	}
	] =
	conn
	\|> get("/api/v1/blocks?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "account lookup", %{conn: conn} do
	%{nickname: acct} = insert(:user, %{nickname: "nickname"})
	%{nickname: acct_two} = insert(:user, %{nickname: "nickname@notlocaldoma.in"})

	result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=#{acct}")
	\|> json_response_and_validate_schema(200)

	assert %{"acct" => ^acct} = result

	result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=#{acct_two}")
	\|> json_response_and_validate_schema(200)

	assert %{"acct" => ^acct_two} = result

	_result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=unexisting_nickname")
	\|> json_response_and_validate_schema(404)
	end

	test "create a note on a user" do
	%{conn: conn} = oauth_access(["write:accounts", "read:follows"])
	other_user = insert(:user)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{other_user.id}/note", %{
	"comment" => "Example note"
	})

	assert [%{"note" => "Example note"}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	describe "account endorsements" do
	setup do: oauth_access(["read:accounts", "write:accounts", "write:follows"])

	setup do: clear_config([:instance, :max_endorsed_users], 1)

	test "pin account", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)

	CommonAPI.follow(other_user1, user)

	assert %{"id" => ^id1, "endorsed" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{id1}/pin")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "unpin account", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)

	CommonAPI.follow(other_user1, user)
	User.endorse(user, other_user1)

	assert %{"id" => ^id1, "endorsed" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{id1}/unpin")
	\|> json_response_and_validate_schema(200)

	assert [] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "max pinned accounts", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)

	CommonAPI.follow(other_user1, user)
	CommonAPI.follow(other_user2, user)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{id1}/pin")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "You have already pinned the maximum number of users"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{id2}/pin")
	\|> json_response_and_validate_schema(400)
	end
	end

	describe "familiar followers" do
	setup do: oauth_access(["read:follows"])

	test "fetch user familiar followers", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [%{"id" => ^id1}], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns empty array if followers are hidden", %{user: user, conn: conn} do
	other_user1 = insert(:user, hide_follows: true)
	%{id: id2} = other_user2 = insert(:user)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end

	test "it respects hide_followers", %{user: user, conn: conn} do
	other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user, hide_followers: true)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "remove from followers" do
	setup do: oauth_access(["follow"])

	test "removing user from followers", %{conn: conn, user: user} do
	%{id: other_user_id} = other_user = insert(:user)

	CommonAPI.follow(user, other_user)

	assert %{"id" => ^other_user_id, "followed_by" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/remove_from_followers")
	\|> json_response_and_validate_schema(200)

	refute User.following?(other_user, user)
	end

	test "removing remote user from followers", %{conn: conn, user: user} do
	%{id: other_user_id} = other_user = insert(:user, local: false)

	CommonAPI.follow(user, other_user)

	assert User.following?(other_user, user)

	assert %{"id" => ^other_user_id, "followed_by" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/remove_from_followers")
	\|> json_response_and_validate_schema(200)

	refute User.following?(other_user, user)
	end

	test "removing user from followers errors", %{user: user, conn: conn} do
	# self remove
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/remove_from_followers")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# remove non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/remove_from_followers")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	index 8fc22dde1..88f2fb7af 100644
	--- a/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	@@ -1,714 +1,714 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
	use Pleroma.Web.ConnCase, async: false

	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	test "does NOT render account/pleroma/relationship by default" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, [_notification]} = Notification.create_notifications(activity)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(200)

	assert Enum.all?(response, fn n ->
	get_in(n, ["account", "pleroma", "relationship"]) == %{}
	end)
	end

	test "list of notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] =
	json_response_and_validate_schema(conn, 200)

	assert response == expected_response
	end

	test "by default, does not contain pleroma:chat_mention" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post_chat_message(other_user, user, "hey")

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(200)

	assert [] == result

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:chat_mention")
	\|> json_response_and_validate_schema(200)

	assert [_] = result
	end

	test "by default, does not contain pleroma:report" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, user} = user \|> User.admin_api_update(%{is_moderator: true})

	%{conn: conn} = oauth_access(["read:notifications"], user: user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})

	{:ok, _report} =
	CommonAPI.report(third_user, %{account_id: other_user.id, status_ids: [activity.id]})

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(200)

	assert [] == result

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [_] = result
	end

	test "Pleroma:report is hidden for non-privileged users" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, user} = user \|> User.admin_api_update(%{is_moderator: true})

	%{conn: conn} = oauth_access(["read:notifications"], user: user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})

	{:ok, _report} =
	CommonAPI.report(third_user, %{account_id: other_user.id, status_ids: [activity.id]})

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [_] = result

	clear_config([:instance, :moderator_privileges], [])

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [] == result
	end

	test "excludes mentions from blockers when blockers_visible is false" do
	clear_config([:activitypub, :blockers_visible], false)

	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	blocker = insert(:user)

	{:ok, _} = CommonAPI.block(user, blocker)
	{:ok, activity} = CommonAPI.post(blocker, %{status: "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting a single notification" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn = get(conn, "/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response_and_validate_schema(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification (deprecated endpoint)" do
	%{user: user, conn: conn} = oauth_access(["write:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/notifications/dismiss", %{"id" => to_string(notification.id)})

	assert %{} = json_response_and_validate_schema(conn, 200)
	end

	test "dismissing a single notification" do
	%{user: user, conn: conn} = oauth_access(["write:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/#{notification.id}/dismiss")

	assert %{} = json_response_and_validate_schema(conn, 200)
	end

	test "clearing all notifications" do
	%{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	ret_conn = post(conn, "/api/v1/notifications/clear")

	assert %{} = json_response_and_validate_schema(ret_conn, 200)

	ret_conn = get(conn, "/api/v1/notifications")

	assert all = json_response_and_validate_schema(ret_conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})

	notification1_id = get_notification_id_by_activity(activity1)
	notification2_id = get_notification_id_by_activity(activity2)
	notification3_id = get_notification_id_by_activity(activity3)
	notification4_id = get_notification_id_by_activity(activity4)

	conn = assign(conn, :user, user)

	# min_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result

	# since_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	# max_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	describe "exclude_visibilities" do
	test "filters notifications for mentions" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, public_activity} =
	CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})

	{:ok, direct_activity} =
	CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})

	{:ok, private_activity} =
	CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})

	query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == direct_activity.id

	query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == private_activity.id

	query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == unlisted_activity.id

	query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == public_activity.id
	end

	test "filters notifications for Like activities" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} =
	CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})

	{:ok, _} = CommonAPI.favorite(public_activity.id, user)
	{:ok, _} = CommonAPI.favorite(direct_activity.id, user)
	{:ok, _} = CommonAPI.favorite(unlisted_activity.id, user)
	{:ok, _} = CommonAPI.favorite(private_activity.id, user)

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=direct")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	assert unlisted_activity.id in activity_ids
	assert private_activity.id in activity_ids
	refute direct_activity.id in activity_ids

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	refute unlisted_activity.id in activity_ids
	assert private_activity.id in activity_ids
	assert direct_activity.id in activity_ids

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=private")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	assert unlisted_activity.id in activity_ids
	refute private_activity.id in activity_ids
	assert direct_activity.id in activity_ids

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=public")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	refute public_activity.id in activity_ids
	assert unlisted_activity.id in activity_ids
	assert private_activity.id in activity_ids
	assert direct_activity.id in activity_ids
	end

	test "filters notifications for Announce activities" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})

	{:ok, _} = CommonAPI.repeat(public_activity.id, user)
	{:ok, _} = CommonAPI.repeat(unlisted_activity.id, user)

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	refute unlisted_activity.id in activity_ids
	end

	test "doesn't return less than the requested amount of records when the user's reply is liked" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{:ok, mention} =
	CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "public"})

	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, reply} =
	CommonAPI.post(other_user, %{
	status: ".",
	visibility: "public",
	in_reply_to_status_id: activity.id
	})

	{:ok, _favorite} = CommonAPI.favorite(reply.id, user)

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=direct&limit=2")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert [reply.id, mention.id] == activity_ids
	end
	end

	test "filters notifications using exclude_types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(user, other_user)

	mention_notification_id = get_notification_id_by_activity(mention_activity)
	favorite_notification_id = get_notification_id_by_activity(favorite_activity)
	reblog_notification_id = get_notification_id_by_activity(reblog_activity)
	follow_notification_id = get_notification_id_by_activity(follow_activity)

	query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)

	query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^mention_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^favorite_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
	end

	test "filters notifications using types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(user, other_user)

	mention_notification_id = get_notification_id_by_activity(mention_activity)
	favorite_notification_id = get_notification_id_by_activity(favorite_activity)
	reblog_notification_id = get_notification_id_by_activity(reblog_activity)
	follow_notification_id = get_notification_id_by_activity(follow_activity)

	conn_res = get(conn, "/api/v1/notifications?types[]=follow")

	assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications?types[]=mention")

	assert [%{"id" => ^mention_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications?types[]=favourite")

	assert [%{"id" => ^favorite_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications?types[]=reblog")

	assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)

	result = conn \|> get("/api/v1/notifications") \|> json_response_and_validate_schema(200)

	assert length(result) == 4

	query = params_to_query(%{types: ["follow", "mention", "favourite", "reblog"]})

	result =
	conn
	\|> get("/api/v1/notifications?" <> query)
	\|> json_response_and_validate_schema(200)

	assert length(result) == 4
	end

	test "filtering falls back to include_types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _activity} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, _activity} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(user, other_user)

	follow_notification_id = get_notification_id_by_activity(follow_activity)

	conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")

	assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
	end

	test "destroy multiple" do
	%{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
	{:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})

	notification1_id = get_notification_id_by_activity(activity1)
	notification2_id = get_notification_id_by_activity(activity2)
	notification3_id = get_notification_id_by_activity(activity3)
	notification4_id = get_notification_id_by_activity(activity4)

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result

	conn2 =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	query = params_to_query(%{ids: [notification1_id, notification2_id]})
	conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)

	assert json_response_and_validate_schema(conn_destroy, 200) == %{}

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
	end

	test "doesn't see notifications after muting user with notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user2, user)
	{:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(ret_conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2)

	conn = get(conn, "/api/v1/notifications")

	assert json_response_and_validate_schema(conn, 200) == []
	end

	test "see notifications after muting user without notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user2, user)
	{:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(ret_conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2, %{notifications: false})

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(conn, 200)) == 1
	end

	test "see notifications after muting user with notifications and with_muted parameter" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user2, user)
	{:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(ret_conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2)

	conn = get(conn, "/api/v1/notifications?with_muted=true")

	assert length(json_response_and_validate_schema(conn, 200)) == 1
	end

	test "see move notifications" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	%{user: follower, conn: conn} = oauth_access(["read:notifications"])

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(conn, 200)) == 1
	end

	describe "link headers" do
	test "preserves parameters in link headers" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(other_user, %{
	status: "hi @#{user.nickname}",
	visibility: "public"
	})

	{:ok, activity2} =
	CommonAPI.post(other_user, %{
	status: "hi @#{user.nickname}",
	visibility: "public"
	})

	notification1 = Repo.get_by(Notification, activity_id: activity1.id)
	notification2 = Repo.get_by(Notification, activity_id: activity2.id)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications?limit=5")

	assert [link_header] = get_resp_header(conn, "link")
	assert link_header =~ ~r/limit=5/
	assert link_header =~ ~r/min_id=#{notification2.id}/
	assert link_header =~ ~r/max_id=#{notification1.id}/
	end
	end

	describe "from specified user" do
	test "account_id" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])

	%{id: account_id} = other_user1 = insert(:user)
	other_user2 = insert(:user)

	{:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
	{:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})

	assert [%{"account" => %{"id" => ^account_id}}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications?account_id=#{account_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "Account is not found"} =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications?account_id=cofe")
	\|> json_response_and_validate_schema(404)
	end
	end

	defp get_notification_id_by_activity(%{id: id}) do
	Notification
	\|> Repo.get_by(activity_id: id)
	\|> Map.get(:id)
	\|> to_string()
	end

	defp params_to_query(%{} = params) do
	Enum.map_join(params, "&", fn
	{k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
	{k, v} -> k <> "=" <> v
	end)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	index d38767c96..d8263dfad 100644
	--- a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	@@ -1,453 +1,453 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Mock

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	setup_all do
	mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe ".search2" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v2/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	@tag :skip_darwin
	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu #private"})}")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == [
	%{"name" => "private", "url" => "#{Endpoint.url()}/tag/private"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)

	results =
	get(conn, "/api/v2/search?q=天子")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "天子", "url" => "#{Endpoint.url()}/tag/天子"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search local-only status as an authenticated user" do
	user = insert(:user)
	%{conn: conn} = oauth_access(["read:search"])

	{:ok, activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search local-only status as an unauthenticated user" do
	user = insert(:user)
	%{conn: conn} = oauth_access([])

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	assert [] = results["statuses"]
	end

	test "search local-only status as an anonymous user" do
	user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	build_conn()
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	assert [] = results["statuses"]
	end

	test "constructs hashtags from search query", %{conn: conn} do
	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "explicit", "url" => "#{Endpoint.url()}/tag/explicit"},
	%{"name" => "hashtags", "url" => "#{Endpoint.url()}/tag/hashtags"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "john", "url" => "#{Endpoint.url()}/tag/john"},
	%{"name" => "doe", "url" => "#{Endpoint.url()}/tag/doe"},
	%{"name" => "JohnDoe", "url" => "#{Endpoint.url()}/tag/JohnDoe"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "accident", "url" => "#{Endpoint.url()}/tag/accident"},
	%{"name" => "prone", "url" => "#{Endpoint.url()}/tag/prone"},
	%{"name" => "AccidentProne", "url" => "#{Endpoint.url()}/tag/AccidentProne"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "https://shpposter.club/users/shpuld"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "shpuld", "url" => "#{Endpoint.url()}/tag/shpuld"}
	]

	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "https://www.washingtonpost.com/sports/2020/06/10/" <> "nascar-ban-display-confederate-flag-all-events-properties/"})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "nascar", "url" => "#{Endpoint.url()}/tag/nascar"},
	%{"name" => "ban", "url" => "#{Endpoint.url()}/tag/ban"},
	%{"name" => "display", "url" => "#{Endpoint.url()}/tag/display"},
	%{"name" => "confederate", "url" => "#{Endpoint.url()}/tag/confederate"},
	%{"name" => "flag", "url" => "#{Endpoint.url()}/tag/flag"},
	%{"name" => "all", "url" => "#{Endpoint.url()}/tag/all"},
	%{"name" => "events", "url" => "#{Endpoint.url()}/tag/events"},
	%{"name" => "properties", "url" => "#{Endpoint.url()}/tag/properties"},
	%{
	"name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
	"url" =>
	"#{Endpoint.url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
	}
	]
	end

	test "supports pagination of hashtags search results", %{conn: conn} do
	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "#some #text #with #hashtags", limit: 2, offset: 1})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "text", "url" => "#{Endpoint.url()}/tag/text"},
	%{"name" => "with", "url" => "#{Endpoint.url()}/tag/with"}
	]
	end

	test "excludes a blocked users from search results", %{conn: conn} do
	user = insert(:user)
	user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
	user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})

	{:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
	{:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
	{:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
	Pleroma.User.block(user, user_smith)

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v2/search?q=Agent")
	\|> json_response_and_validate_schema(200)

	status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)

	assert act3.id in status_ids
	refute act2.id in status_ids
	refute act1.id in status_ids
	end
	end

	describe ".account_search" do
	test "account search", %{conn: conn} do
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> get("/api/v1/accounts/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "returns account if query contains a space", %{conn: conn} do
	insert(:user, %{nickname: "shp@shitposter.club"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
	\|> json_response_and_validate_schema(200)

	assert length(results) == 1
	end
	end

	describe ".search" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == ["2hu"]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses and prefers them over other results", %{conn: conn} do
	{:ok, %{id: activity_id}} =
	CommonAPI.post(insert(:user), %{
	status: "check out http://mastodon.example.org/@admin/99541947525187367"
	})

	%{"url" => result_url, "id" => result_id} =
	conn
	\|> get("/api/v1/search?q=http://mastodon.example.org/@admin/99541947525187367")
	\|> json_response_and_validate_schema(200)
	\|> Map.get("statuses")
	\|> List.first()

	refute match?(^result_id, activity_id)
	assert match?(^result_url, "http://mastodon.example.org/@admin/99541947525187367")
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	capture_log(fn ->
	q = Object.normalize(activity, fetch: false).data["id"]

	results =
	conn
	\|> get("/api/v1/search?q=#{q}")
	\|> json_response_and_validate_schema(200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	user = insert(:user)

	query = URI.encode_query(%{q: " mike@osada.macgirvin.com ", resolve: true})

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v1/search?#{query}")
	\|> json_response_and_validate_schema(200)

	[account] = results["accounts"]
	assert account["acct"] == "mike@osada.macgirvin.com"
	end

	test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
	results =
	conn
	\|> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
	\|> json_response_and_validate_schema(200)

	assert [] == results["accounts"]
	end

	test "search with limit and offset", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	_user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})

	result =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1")

	assert results = json_response_and_validate_schema(result, 200)
	assert [%{"id" => activity_id1}] = results["statuses"]
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1&offset=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert [] = results["accounts"]

	assert activity_id1 != activity_id2
	end

	test "search returns results only for the given type", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})

	assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=statuses")
	\|> json_response_and_validate_schema(200)

	assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=accounts")
	\|> json_response_and_validate_schema(200)
	end

	test "search uses account_id to filter statuses by the author", %{conn: conn} do
	user = insert(:user, %{nickname: "shp@shitposter.club"})
	user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id1}] = results["statuses"]
	assert activity_id1 == activity1.id
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert activity_id2 == activity2.id
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/notification_view_test.exs b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	index b1f3523ac..ce5ddd0fc 100644
	--- a/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	@@ -1,374 +1,374 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
	use Pleroma.DataCase, async: false

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
	import Pleroma.Factory

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	defp test_notifications_rendering(notifications, user, expected_result) do
	result = NotificationView.render("index.json", %{notifications: notifications, for: user})

	assert expected_result == result

	result =
	NotificationView.render("index.json", %{
	notifications: notifications,
	for: user,
	relationships: nil
	})

	assert expected_result == result
	end

	test "ChatMessage notification" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "what's up my dude")

	{:ok, [notification]} = Notification.create_notifications(activity)

	object = Object.normalize(activity, fetch: false)
	chat = Chat.get(recipient.id, user.ap_id)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:chat_mention",
	account: AccountView.render("show.json", %{user: user, for: recipient}),
	chat_message: MessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], recipient, [expected])
	end

	test "Mention notification" do
	user = insert(:user)
	mentioned_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
	{:ok, [notification]} = Notification.create_notifications(activity)
	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "mention",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: mentioned_user
	}),
	status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], mentioned_user, [expected])
	end

	test "Favourite notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Reblog notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(reblog_activity)
	reblog_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "reblog",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Follow notification" do
	follower = insert(:user)
	followed = insert(:user)
	{:ok, followed, follower, _activity} = CommonAPI.follow(followed, follower)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "follow",
	account: AccountView.render("show.json", %{user: follower, for: followed}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], followed, [expected])

	User.perform(:delete, follower)
	refute Repo.one(Notification)
	end

	test "Move notification" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	follower = insert(:user)

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

	old_user = refresh_record(old_user)
	new_user = refresh_record(new_user)

	[notification] = Notification.for_user(follower)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "move",
	account: AccountView.render("show.json", %{user: old_user, for: follower}),
	target: AccountView.render("show.json", %{user: new_user, for: follower}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], follower, [expected])
	end

	test "EmojiReact notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	{:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:emoji_reaction",
	emoji: "☕",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	emoji_url: nil
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "EmojiReact custom emoji notification" do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [
	["👍", [user.ap_id], nil],
	["dinosaur", [user.ap_id], "http://localhost:4001/emoji/dino walking.gif"]
	]
	}
	)

	activity = insert(:note_activity, note: note, user: user)

	{:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "dinosaur")

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:emoji_reaction",
	emoji: ":dinosaur:",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	emoji_url: "http://localhost:4001/emoji/dino walking.gif"
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Poll notification" do
	user = insert(:user)
	activity = insert(:question_activity, user: user)
	{:ok, [notification]} = Notification.create_poll_notifications(activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "poll",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: user
	}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Report notification" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	{:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:report",
	account: AccountView.render("show.json", %{user: reporting_user, for: moderator_user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	report: ReportView.render("show.json", Report.extract_report_info(activity))
	}

	test_notifications_rendering([notification], moderator_user, [expected])
	end

	test "Edit notification" do
	user = insert(:user)
	repeat_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew"})
	{:ok, _} = CommonAPI.repeat(activity.id, repeat_user)
	{:ok, update} = CommonAPI.update(activity, user, %{status: "mew mew"})

	user = Pleroma.User.get_by_ap_id(user.ap_id)
	activity = Pleroma.Activity.normalize(activity)
	update = Pleroma.Activity.normalize(update)

	{:ok, [notification]} = Notification.create_notifications(update)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "update",
	account: AccountView.render("show.json", %{user: user, for: repeat_user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	status: StatusView.render("show.json", %{activity: activity, for: repeat_user})
	}

	test_notifications_rendering([notification], repeat_user, [expected])
	end

	test "muted notification" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, _} = Pleroma.UserRelationship.create_mute(user, another_user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: true, is_muted: true},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Subscribed status notification" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hi"})
	{:ok, [notification]} = Notification.create_notifications(activity)

	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "status",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: subscriber
	}),
	status: StatusView.render("show.json", %{activity: activity, for: subscriber}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], subscriber, [expected])
	end
	end
	diff --git a/test/pleroma/web/o_auth/app_test.exs b/test/pleroma/web/o_auth/app_test.exs
	index 44219cf90..a69ba371e 100644
	--- a/test/pleroma/web/o_auth/app_test.exs
	+++ b/test/pleroma/web/o_auth/app_test.exs
	@@ -1,73 +1,85 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.AppTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Web.OAuth.App
	import Pleroma.Factory

	describe "get_or_make/2" do
	test "gets exist app" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	app = insert(:oauth_app, Map.merge(attrs, %{scopes: ["read", "write"]}))
	{:ok, %App{} = exist_app} = App.get_or_make(attrs, [])
	assert exist_app == app
	end

	test "make app" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	{:ok, %App{} = app} = App.get_or_make(attrs, ["write"])
	assert app.scopes == ["write"]
	end

	test "gets exist app and updates scopes" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	app = insert(:oauth_app, Map.merge(attrs, %{scopes: ["read", "write"]}))
	{:ok, %App{} = exist_app} = App.get_or_make(attrs, ["read", "write", "follow", "push"])
	assert exist_app.id == app.id
	assert exist_app.scopes == ["read", "write", "follow", "push"]
	end

	test "has unique client_id" do
	insert(:oauth_app, client_name: "", redirect_uris: "", client_id: "boop")

	error =
	catch_error(insert(:oauth_app, client_name: "", redirect_uris: "", client_id: "boop"))

	assert %Ecto.ConstraintError{} = error
	assert error.constraint == "apps_client_id_index"
	assert error.type == :unique
	end
	end

	test "get_user_apps/1" do
	user = insert(:user)

	apps = [
	insert(:oauth_app, user_id: user.id),
	insert(:oauth_app, user_id: user.id),
	insert(:oauth_app, user_id: user.id)
	]

	assert Enum.sort(App.get_user_apps(user)) == Enum.sort(apps)
	end

	test "removes orphaned apps" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	{:ok, %App{} = old_app} = App.get_or_make(attrs, ["write"])

	+ # backdate the old app so it's within the threshold for being cleaned up
	+ one_hour_ago = DateTime.add(DateTime.utc_now(), -3600)
	+
	+ {:ok, _} =
	+ "UPDATE apps SET inserted_at = $1, updated_at = $1 WHERE id = $2"
	+ \|> Pleroma.Repo.query([one_hour_ago, old_app.id])
	+
	+ # Create the new app after backdating the old one
	attrs = %{client_name: "PleromaFE", redirect_uris: "."}
	{:ok, %App{} = app} = App.get_or_make(attrs, ["write"])

	- # backdate the old app so it's within the threshold for being cleaned up
	+ # Ensure the new app has a recent timestamp
	+ now = DateTime.utc_now()
	+
	{:ok, _} =
	- "UPDATE apps SET inserted_at = now() - interval '1 hour' WHERE id = #{old_app.id}"
	- \|> Pleroma.Repo.query()
	+ "UPDATE apps SET inserted_at = $1, updated_at = $1 WHERE id = $2"
	+ \|> Pleroma.Repo.query([now, app.id])

	App.remove_orphans()

	- assert [app] == Pleroma.Repo.all(App)
	+ assert [returned_app] = Pleroma.Repo.all(App)
	+ assert returned_app.client_name == "PleromaFE"
	+ assert returned_app.id == app.id
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
	index 8c2dcc1bb..c1e452a1e 100644
	--- a/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
	@@ -1,375 +1,375 @@
	# 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.EmojiReactionControllerTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	test "PUT /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	note = insert(:note, user: user, data: %{"reactions" => [["👍", [other_user.ap_id], nil]]})
	activity = insert(:note_activity, note: note, user: user)

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/\u26A0")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => id} = result
	assert to_string(activity.id) == id

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	"name" => "👍",
	"count" => 1,
	"me" => true,
	"url" => nil,
	"account_ids" => [other_user.id]
	},
	%{
	"name" => "\u26A0\uFE0F",
	"count" => 1,
	"me" => true,
	"url" => nil,
	"account_ids" => [other_user.id]
	}
	]

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	ObanHelpers.perform_all()

	# Reacting with a custom emoji
	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/:dinosaur:")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => id} = result
	assert to_string(activity.id) == id

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	"name" => "dinosaur",
	"count" => 1,
	"me" => true,
	"url" => "http://localhost:4001/emoji/dino walking.gif",
	"account_ids" => [other_user.id]
	}
	]

	# Reacting with a remote emoji
	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [
	["👍", [other_user.ap_id], nil],
	["wow", [other_user.ap_id], "https://remote/emoji/wow"]
	]
	}
	)

	activity = insert(:note_activity, note: note, user: user)

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/:wow@remote:")
	\|> json_response(200)

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	"account_ids" => [other_user.id],
	"count" => 1,
	"me" => false,
	"name" => "👍",
	"url" => nil
	},
	%{
	"name" => "wow@remote",
	"count" => 2,
	"me" => true,
	"url" => "https://remote/emoji/wow",
	"account_ids" => [user.id, other_user.id]
	}
	]

	# Reacting with a remote custom emoji that hasn't been reacted with yet
	note =
	insert(:note,
	user: user
	)

	activity = insert(:note_activity, note: note, user: user)

	assert conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/:wow@remote:")
	\|> json_response(400)

	# Reacting with a non-emoji
	assert conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/x")
	\|> json_response_and_validate_schema(400)
	end

	test "DELETE /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{"reactions" => [["wow", [user.ap_id], "https://remote/emoji/wow"]]}
	)

	activity = insert(:note_activity, note: note, user: user)

	ObanHelpers.perform_all()

	{:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
	{:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")

	{:ok, _reaction_activity} =
	CommonAPI.react_with_emoji(activity.id, other_user, ":wow@remote:")

	ObanHelpers.perform_all()

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/☕")

	assert %{"id" => id} = json_response_and_validate_schema(result, 200)
	assert to_string(activity.id) == id

	# Remove custom emoji

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/:dinosaur:")

	assert %{"id" => id} = json_response_and_validate_schema(result, 200)
	assert to_string(activity.id) == id

	ObanHelpers.perform_all()

	object = Object.get_by_ap_id(activity.data["object"])

	assert object.data["reaction_count"] == 2

	# Remove custom remote emoji
	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/:wow@remote:")
	\|> json_response(200)

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	"name" => "wow@remote",
	"count" => 1,
	"me" => false,
	"url" => "https://remote/emoji/wow",
	"account_ids" => [user.id]
	}
	]

	# Remove custom remote emoji that hasn't been reacted with yet
	assert conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/:zoop@remote:")
	\|> json_response(400)
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	doomed_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert result == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, doomed_user, "🎅")

	User.perform(:delete, doomed_user)

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	[%{"name" => "🎅", "count" => 1, "accounts" => [represented_user], "me" => false}] = result

	assert represented_user["id"] == other_user.id

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:statuses"]))
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 1, "accounts" => [_represented_user], "me" => true}] =
	result
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions with legacy format", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	activity = insert(:note_activity, user: user, note: note)

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	other_user_id = other_user.id

	assert [
	%{
	"name" => "😿",
	"count" => 1,
	"me" => false,
	"url" => nil,
	"accounts" => [%{"id" => ^other_user_id}]
	}
	] = result
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions?with_muted=true", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user2, "🎅")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user3, "🎅")

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 2}] = result

	User.mute(user, user3)

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 1}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 2}] = result
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions with :show_reactions disabled", %{conn: conn} do
	clear_config([:instance, :show_reactions], false)

	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert result == []
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions/🎅")
	\|> json_response_and_validate_schema(200)

	assert result == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	assert [
	%{
	"name" => "🎅",
	"count" => 1,
	"accounts" => [represented_user],
	"me" => false,
	"url" => nil
	}
	] =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions/🎅")
	\|> json_response_and_validate_schema(200)

	assert represented_user["id"] == other_user.id
	end
	end
	diff --git a/test/pleroma/workers/cron/digest_emails_worker_test.exs b/test/pleroma/workers/cron/digest_emails_worker_test.exs
	index e0bdf303e..46be82a4f 100644
	--- a/test/pleroma/workers/cron/digest_emails_worker_test.exs
	+++ b/test/pleroma/workers/cron/digest_emails_worker_test.exs
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.DigestEmailsWorkerTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	setup do: clear_config([:email_notifications, :digest])

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	setup do
	clear_config([:email_notifications, :digest], %{
	active: true,
	inactivity_threshold: 7,
	interval: 7
	})

	user = insert(:user)

	date =
	Timex.now()
	\|> Timex.shift(days: -10)
	\|> Timex.to_naive_datetime()

	user2 = insert(:user, last_digest_emailed_at: date)
	{:ok, _} = User.switch_email_notifications(user2, "digest", true)
	CommonAPI.post(user, %{status: "hey @#{user2.nickname}!"})

	{:ok, user2: user2}
	end

	test "it sends digest emails", %{user2: user2} do
	Pleroma.Workers.Cron.DigestEmailsWorker.perform(%Oban.Job{})
	# Performing job(s) enqueued at previous step
	ObanHelpers.perform_all()

	assert_received {:email, email}
	assert email.to == [{user2.name, user2.email}]
	assert email.subject == "Your digest from #{Pleroma.Config.get(:instance)[:name]}"
	end

	test "it doesn't fail when a user has no email", %{user2: user2} do
	{:ok, _} = user2 \|> Ecto.Changeset.change(%{email: nil}) \|> Pleroma.Repo.update()

	Pleroma.Workers.Cron.DigestEmailsWorker.perform(%Oban.Job{})
	# Performing job(s) enqueued at previous step
	ObanHelpers.perform_all()
	end
	end
	diff --git a/test/pleroma/workers/cron/new_users_digest_worker_test.exs b/test/pleroma/workers/cron/new_users_digest_worker_test.exs
	index 0e4234cc8..ca4139eac 100644
	--- a/test/pleroma/workers/cron/new_users_digest_worker_test.exs
	+++ b/test/pleroma/workers/cron/new_users_digest_worker_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 Pleroma.Workers.Cron.NewUsersDigestWorkerTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.Cron.NewUsersDigestWorker

	setup do
	- Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	+ Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	test "it sends new users digest emails" do
	yesterday = NaiveDateTime.utc_now() \|> Timex.shift(days: -1)
	admin = insert(:user, %{is_admin: true})
	user = insert(:user, %{inserted_at: yesterday})
	user2 = insert(:user, %{inserted_at: yesterday})
	CommonAPI.post(user, %{status: "cofe"})

	NewUsersDigestWorker.perform(%Oban.Job{})
	ObanHelpers.perform_all()

	assert_received {:email, email}
	assert email.to == [{admin.name, admin.email}]
	assert email.subject == "#{Pleroma.Config.get([:instance, :name])} New Users"

	refute email.html_body =~ admin.nickname
	assert email.html_body =~ user.nickname
	assert email.html_body =~ user2.nickname
	assert email.html_body =~ "cofe"
	assert email.html_body =~ "#{Pleroma.Web.Endpoint.url()}/static/logo.svg"
	end

	test "it doesn't fail when admin has no email" do
	yesterday = NaiveDateTime.utc_now() \|> Timex.shift(days: -1)
	insert(:user, %{is_admin: true, email: nil})
	insert(:user, %{inserted_at: yesterday})
	user = insert(:user, %{inserted_at: yesterday})

	CommonAPI.post(user, %{status: "cofe"})

	NewUsersDigestWorker.perform(%Oban.Job{})
	ObanHelpers.perform_all()
	end
	end
	diff --git a/test/support/data_case.ex b/test/support/data_case.ex
	index 52d4bef1a..304bee5da 100644
	--- a/test/support/data_case.ex
	+++ b/test/support/data_case.ex
	@@ -1,146 +1,148 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.DataCase do
	@moduledoc """
	This module defines the setup for tests requiring
	access to the application's data layer.

	You may define functions here to be used as helpers in
	your tests.

	Finally, if the test case interacts with the database,
	it cannot be async. For this reason, every test runs
	inside a transaction which is reset at the beginning
	of the test unless the test case is marked as async.
	"""

	use ExUnit.CaseTemplate

	import Pleroma.Tests.Helpers, only: [clear_config: 2]

	using do
	quote do
	alias Pleroma.Repo

	import Ecto
	import Ecto.Changeset
	import Ecto.Query
	import Pleroma.DataCase
	use Pleroma.Tests.Helpers

	# Sets up OAuth access with specified scopes
	defp oauth_access(scopes, opts \\ []) do
	user =
	Keyword.get_lazy(opts, :user, fn ->
	Pleroma.Factory.insert(:user)
	end)

	token =
	Keyword.get_lazy(opts, :oauth_token, fn ->
	Pleroma.Factory.insert(:oauth_token, user: user, scopes: scopes)
	end)

	%{user: user, token: token}
	end
	end
	end

	def clear_cachex do
	Pleroma.Supervisor
	\|> Supervisor.which_children()
	\|> Enum.each(fn
	{name, _, _, [Cachex]} ->
	name
	\|> to_string
	\|> String.trim_leading("cachex_")
	\|> Kernel.<>("_cache")
	\|> String.to_existing_atom()
	\|> Cachex.clear()

	_ ->
	nil
	end)
	end

	def setup_multi_process_mode(tags) do
	:ok = Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)

	if tags[:async] do
	Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	Mox.set_mox_private()
	else
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})

	Mox.set_mox_global()
	Mox.stub_with(Pleroma.CachexMock, Pleroma.CachexProxy)
	clear_cachex()
	end

	:ok
	end

	def setup_streamer(tags) do
	if tags[:needs_streamer] do
	start_supervised(%{
	id: Pleroma.Web.Streamer.registry(),
	start:
	{Registry, :start_link, [[keys: :duplicate, name: Pleroma.Web.Streamer.registry()]]}
	})
	end

	:ok
	end

	setup tags do
	setup_multi_process_mode(tags)
	setup_streamer(tags)
	stub_pipeline()

	Mox.verify_on_exit!()

	:ok
	end

	def stub_pipeline do
	Mox.stub_with(Pleroma.Web.ActivityPub.SideEffectsMock, Pleroma.Web.ActivityPub.SideEffects)

	Mox.stub_with(
	Pleroma.Web.ActivityPub.ObjectValidatorMock,
	Pleroma.Web.ActivityPub.ObjectValidator
	)

	Mox.stub_with(Pleroma.Web.ActivityPub.MRFMock, Pleroma.Web.ActivityPub.MRF)
	Mox.stub_with(Pleroma.Web.ActivityPub.ActivityPubMock, Pleroma.Web.ActivityPub.ActivityPub)
	Mox.stub_with(Pleroma.Web.FederatorMock, Pleroma.Web.Federator)
	Mox.stub_with(Pleroma.ConfigMock, Pleroma.Config)
	Mox.stub_with(Pleroma.StaticStubbedConfigMock, Pleroma.Test.StaticConfig)
	Mox.stub_with(Pleroma.StubbedHTTPSignaturesMock, Pleroma.Test.HTTPSignaturesProxy)
	+
	+ Mox.stub_with(Pleroma.DateTimeMock, Pleroma.DateTime.Impl)
	end

	def ensure_local_uploader(context) do
	test_uploader = Map.get(context, :uploader) \|\| Pleroma.Uploaders.Local

	clear_config([Pleroma.Upload, :uploader], test_uploader)
	clear_config([Pleroma.Upload, :filters], [])

	:ok
	end

	@doc """
	A helper that transform changeset errors to a map of messages.

	changeset = Accounts.create_user(%{password: "short"})
	assert "password is too short" in errors_on(changeset).password
	assert %{password: ["password is too short"]} = errors_on(changeset)

	"""
	def errors_on(changeset) do
	Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
	Enum.reduce(opts, message, fn {key, value}, acc ->
	String.replace(acc, "%{#{key}}", to_string(value))
	end)
	end)
	end
	end
	diff --git a/test/support/mocks.ex b/test/support/mocks.ex
	index d84958e15..ca2974504 100644
	--- a/test/support/mocks.ex
	+++ b/test/support/mocks.ex
	@@ -1,35 +1,38 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	Mox.defmock(Pleroma.CachexMock, for: Pleroma.Caching)

	Mox.defmock(Pleroma.Web.ActivityPub.ObjectValidatorMock,
	for: Pleroma.Web.ActivityPub.ObjectValidator.Validating
	)

	Mox.defmock(Pleroma.Web.ActivityPub.MRFMock,
	for: Pleroma.Web.ActivityPub.MRF.PipelineFiltering
	)

	Mox.defmock(Pleroma.Web.ActivityPub.ActivityPubMock,
	for: [
	Pleroma.Web.ActivityPub.ActivityPub.Persisting,
	Pleroma.Web.ActivityPub.ActivityPub.Streaming
	]
	)

	Mox.defmock(Pleroma.Web.ActivityPub.SideEffectsMock,
	for: Pleroma.Web.ActivityPub.SideEffects.Handling
	)

	Mox.defmock(Pleroma.Web.FederatorMock, for: Pleroma.Web.Federator.Publishing)

	Mox.defmock(Pleroma.ConfigMock, for: Pleroma.Config.Getting)
	Mox.defmock(Pleroma.UnstubbedConfigMock, for: Pleroma.Config.Getting)
	Mox.defmock(Pleroma.StaticStubbedConfigMock, for: Pleroma.Config.Getting)
	Mox.defmock(Pleroma.StubbedHTTPSignaturesMock, for: Pleroma.HTTPSignaturesAPI)

	Mox.defmock(Pleroma.LoggerMock, for: Pleroma.Logging)

	Mox.defmock(Pleroma.Uploaders.S3.ExAwsMock, for: Pleroma.Uploaders.S3.ExAwsAPI)
	+
	+Mox.defmock(Pleroma.DateTimeMock, for: Pleroma.DateTime)
	+Mox.defmock(Pleroma.MogrifyMock, for: Pleroma.MogrifyBehaviour)
	diff --git a/test/test_helper.exs b/test/test_helper.exs
	index fed7ce8a7..94661353b 100644
	--- a/test/test_helper.exs
	+++ b/test/test_helper.exs
	@@ -1,40 +1,46 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	Code.put_compiler_option(:warnings_as_errors, true)

	ExUnit.configure(capture_log: true, max_cases: System.schedulers_online())

	ExUnit.start(exclude: [:federated])

	if match?({:unix, :darwin}, :os.type()) do
	excluded = ExUnit.configuration() \|> Keyword.get(:exclude, [])
	excluded = excluded ++ [:skip_darwin]
	ExUnit.configure(exclude: excluded)
	end

	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, :manual)

	Mox.defmock(Pleroma.ReverseProxy.ClientMock, for: Pleroma.ReverseProxy.Client)
	Mox.defmock(Pleroma.GunMock, for: Pleroma.Gun)

	{:ok, _} = Application.ensure_all_started(:ex_machina)

	ExUnit.after_suite(fn _results ->
	uploads = Pleroma.Config.get([Pleroma.Uploaders.Local, :uploads], "test/uploads")
	File.rm_rf!(uploads)
	end)

	defmodule Pleroma.Test.StaticConfig do
	@moduledoc """
	This module provides a Config that is completely static, built at startup time from the environment. It's safe to use in testing as it will not modify any state.
	"""

	@behaviour Pleroma.Config.Getting
	@config Application.get_all_env(:pleroma)

	+ @impl true
	def get(path, default \\ nil) do
	get_in(@config, path) \|\| default
	end
	+
	+ @impl true
	+ def get!(path) do
	+ get_in(@config, path)
	+ end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 9, 7:59 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1784536
Default Alt Text: (521 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions