No OneTemporary
Actions

Size

548 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/changelog.d/3880.remove b/changelog.d/3880.remove
	new file mode 100644
	index 000000000..113c76c85
	--- /dev/null
	+++ b/changelog.d/3880.remove
	@@ -0,0 +1 @@
	+Cleanup OStatus-era user upgrades and ap_enabled indicator
	\ No newline at end of file
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index f6e30555c..ce125d608 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2724 +1,2713 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Ecto, only: [assoc: 2]

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Emoji
	alias Pleroma.FollowingRelationship
	alias Pleroma.Formatter
	alias Pleroma.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker

	require Logger

	@type t :: %__MODULE__{}
	@type account_status ::
	:active
	\| :deactivated
	\| :password_reset_pending
	\| :confirmation_pending
	\| :approval_pending
	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	],
	endorsement: [
	endorser_endorsements: :endorsed_users,
	endorsee_endorsements: :endorser_users
	]
	]

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

	schema "users" do
	field(:bio, :string, default: "")
	field(:raw_bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:keys, :string)
	field(:public_key, :string)
	field(:ap_id, :string)
	field(:avatar, :map, default: %{})
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:featured_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:following_count, :integer, default: 0)
	field(:is_locked, :boolean, default: false)
	field(:is_confirmed, :boolean, default: true)
	field(:password_reset_pending, :boolean, default: false)
	field(:is_approved, :boolean, default: true)
	field(:registration_reason, :string, default: nil)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {:array, :string}, default: [])
	field(:is_active, :boolean, default: true)
	field(:no_rich_text, :boolean, default: false)
	- field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:uri, ObjectValidators.Uri, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, :map, default: %{})
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: [])
	field(:raw_fields, {:array, :map}, default: [])
	field(:is_discoverable, :boolean, default: false)
	field(:invisible, :boolean, default: false)
	field(:allow_following_move, :boolean, default: true)
	field(:skip_thread_containment, :boolean, default: false)
	field(:actor_type, :string, default: "Person")
	field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
	field(:inbox, :string)
	field(:shared_inbox, :string)
	field(:accepts_chat_messages, :boolean, default: nil)
	field(:last_active_at, :naive_datetime)
	field(:disclose_client, :boolean, default: true)
	field(:pinned_objects, :map, default: %{})
	field(:is_suggested, :boolean, default: false)
	field(:last_status_at, :naive_datetime)
	field(:birthday, :date)
	field(:show_birthday, :boolean, default: false)
	field(:language, :string)

	embeds_one(
	:notification_settings,
	Pleroma.User.NotificationSetting,
	on_replace: :update
	)

	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)

	has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
	has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)

	for {relationship_type,
	[
	{outgoing_relation, outgoing_relation_target},
	{incoming_relation, incoming_relation_source}
	]} <- @user_relationships_config do
	# Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
	# :notification_muter_mutes, :subscribee_subscriptions, :endorser_endorsements
	has_many(outgoing_relation, UserRelationship,
	foreign_key: :source_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
	# :notification_mutee_mutes, :subscriber_subscriptions, :endorsee_endorsements
	has_many(incoming_relation, UserRelationship,
	foreign_key: :target_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
	# :notification_muted_users, :subscriber_users, :endorsed_users
	has_many(outgoing_relation_target, through: [outgoing_relation, :target])

	# Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
	# :notification_muter_users, :subscribee_users, :endorser_users
	has_many(incoming_relation_source, through: [incoming_relation, :source])
	end

	# `:blocks` is deprecated (replaced with `blocked_users` relation)
	field(:blocks, {:array, :string}, default: [])
	# `:mutes` is deprecated (replaced with `muted_users` relation)
	field(:mutes, {:array, :string}, default: [])
	# `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
	field(:muted_reblogs, {:array, :string}, default: [])
	# `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
	field(:muted_notifications, {:array, :string}, default: [])
	# `:subscribers` is deprecated (replaced with `subscriber_users` relation)
	field(:subscribers, {:array, :string}, default: [])

	embeds_one(
	:multi_factor_authentication_settings,
	MFA.Settings,
	on_replace: :delete
	)

	timestamps()
	end

	for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
	@user_relationships_config do
	# `def blocked_users_relation/2`, `def muted_users_relation/2`,
	# `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
	# `def subscriber_users/2`, `def endorsed_users_relation/2`
	def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
	target_users_query = assoc(user, unquote(outgoing_relation_target))

	if restrict_deactivated? do
	target_users_query
	\|> User.Query.build(%{deactivated: false})
	else
	target_users_query
	end
	end

	# `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
	# `def notification_muted_users/2`, `def subscriber_users/2`, `def endorsed_users/2`
	def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> Repo.all()
	end

	# `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
	# `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`,
	# `def endorsed_users_ap_ids/2`
	def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end
	end

	def cached_blocked_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
	blocked_users_ap_ids(user)
	end)
	end

	def cached_muted_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
	muted_users_ap_ids(user)
	end)
	end

	defdelegate following_count(user), to: FollowingRelationship
	defdelegate following(user), to: FollowingRelationship
	defdelegate following?(follower, followed), to: FollowingRelationship
	defdelegate following_ap_ids(user), to: FollowingRelationship
	defdelegate get_follow_requests(user), to: FollowingRelationship
	defdelegate search(query, opts \\ []), to: User.Search

	@doc """
	Dumps Flake Id to SQL-compatible format (16-byte UUID).
	E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
	"""
	def binary_id(source_id) when is_binary(source_id) do
	with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
	dumped_id
	else
	_ -> source_id
	end
	end

	def binary_id(source_ids) when is_list(source_ids) do
	Enum.map(source_ids, &binary_id/1)
	end

	def binary_id(%User{} = user), do: binary_id(user.id)

	@doc "Returns status account"
	@spec account_status(User.t()) :: account_status()
	def account_status(%User{is_active: false}), do: :deactivated
	def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
	def account_status(%User{local: true, is_approved: false}), do: :approval_pending
	def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
	def account_status(%User{}), do: :active

	@spec visible_for(User.t(), User.t() \| nil) ::
	:visible
	\| :invisible
	\| :restricted_unauthenticated
	\| :deactivated
	\| :confirmation_pending
	def visible_for(user, for_user \\ nil)

	def visible_for(%User{invisible: true}, _), do: :invisible

	def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible

	def visible_for(%User{} = user, nil) do
	if restrict_unauthenticated?(user) do
	:restrict_unauthenticated
	else
	visible_account_status(user)
	end
	end

	def visible_for(%User{} = user, for_user) do
	if privileged?(for_user, :users_manage_activation_state) do
	:visible
	else
	visible_account_status(user)
	end
	end

	def visible_for(_, _), do: :invisible

	defp restrict_unauthenticated?(%User{local: true}) do
	Config.restrict_unauthenticated_access?(:profiles, :local)
	end

	defp restrict_unauthenticated?(%User{local: _}) do
	Config.restrict_unauthenticated_access?(:profiles, :remote)
	end

	defp visible_account_status(user) do
	status = account_status(user)

	if status in [:active, :password_reset_pending] do
	:visible
	else
	status
	end
	end

	@spec privileged?(User.t(), atom()) :: boolean()
	def privileged?(%User{is_admin: false, is_moderator: false}, _), do: false

	def privileged?(
	%User{local: true, is_admin: is_admin, is_moderator: is_moderator},
	privilege_tag
	),
	do:
	privileged_for?(privilege_tag, is_admin, :admin_privileges) or
	privileged_for?(privilege_tag, is_moderator, :moderator_privileges)

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

	defp privileged_for?(privilege_tag, true, config_role_key),
	do: privilege_tag in Config.get([:instance, config_role_key])

	defp privileged_for?(_, _, _), do: false

	@spec privileges(User.t()) :: [atom()]
	def privileges(%User{local: false}) do
	[]
	end

	def privileges(%User{is_moderator: false, is_admin: false}) do
	[]
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: true}) do
	(Config.get([:instance, :moderator_privileges]) ++ Config.get([:instance, :admin_privileges]))
	\|> Enum.uniq()
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: false}) do
	Config.get([:instance, :moderator_privileges])
	end

	def privileges(%User{local: true, is_moderator: false, is_admin: true}) do
	Config.get([:instance, :admin_privileges])
	end

	@spec invisible?(User.t()) :: boolean()
	def invisible?(%User{invisible: true}), do: true
	def invisible?(_), do: false

	def avatar_url(user, options \\ []) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} ->
	href

	_ ->
	unless options[:no_default] do
	Config.get([:assets, :default_user_avatar], "#{Endpoint.url()}/images/avi.png")
	end
	end
	end

	def banner_url(user, options \\ []) do
	case user.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{Endpoint.url()}/images/banner.png"
	end
	end

	# Should probably be renamed or removed
	@spec ap_id(User.t()) :: String.t()
	def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"

	@spec ap_followers(User.t()) :: String.t()
	def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	@spec ap_following(User.t()) :: String.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	@spec ap_featured_collection(User.t()) :: String.t()
	def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa

	def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params

	defp fix_follower_address(%{nickname: nickname} = params),
	do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))

	defp fix_follower_address(params), do: params

	def remote_user_changeset(struct \\ %User{local: false}, params) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	name =
	case params[:name] do
	name when is_binary(name) and byte_size(name) > 0 -> name
	_ -> params[:nickname]
	end

	params =
	params
	\|> Map.put(:name, name)
	\|> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)
	\|> truncate_fields_param()
	\|> fix_follower_address()

	struct
	\|> cast(
	params,
	[
	:bio,
	:emoji,
	:ap_id,
	:inbox,
	:shared_inbox,
	:nickname,
	:public_key,
	:avatar,
	- :ap_enabled,
	:banner,
	:is_locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_address,
	:featured_address,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:is_discoverable,
	:invisible,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages,
	:pinned_objects,
	:birthday,
	:show_birthday
	]
	)
	\|> cast(params, [:name], empty_values: [])
	\|> validate_required([:ap_id])
	\|> validate_required([:name], trim: false)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)
	\|> validate_non_local()
	end

	defp validate_non_local(cng) do
	local? = get_field(cng, :local)

	if local? do
	cng
	\|> add_error(:local, "User is local, can't update with this changeset.")
	else
	cng
	end
	end

	def update_changeset(struct, params \\ %{}) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	struct
	\|> cast(
	params,
	[
	:bio,
	:raw_bio,
	:name,
	:emoji,
	:avatar,
	:public_key,
	:inbox,
	:shared_inbox,
	:is_locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:also_known_as,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:is_discoverable,
	:actor_type,
	:accepts_chat_messages,
	:disclose_client,
	:birthday,
	:show_birthday
	]
	)
	\|> validate_min_age()
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	\|> put_fields()
	\|> put_emoji()
	\|> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
	\|> put_change_if_present(:avatar, &put_upload(&1, :avatar))
	\|> put_change_if_present(:banner, &put_upload(&1, :banner))
	\|> put_change_if_present(:background, &put_upload(&1, :background))
	\|> put_change_if_present(
	:pleroma_settings_store,
	&{:ok, Map.merge(struct.pleroma_settings_store, &1)}
	)
	\|> validate_fields(false)
	end

	defp put_fields(changeset) do
	if raw_fields = get_change(changeset, :raw_fields) do
	raw_fields =
	raw_fields
	\|> Enum.filter(fn %{"name" => n} -> n != "" end)

	fields =
	raw_fields
	\|> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)

	changeset
	\|> put_change(:raw_fields, raw_fields)
	\|> put_change(:fields, fields)
	else
	changeset
	end
	end

	defp parse_fields(value) do
	value
	\|> Formatter.linkify(mentions_format: :full)
	\|> elem(0)
	end

	defp put_emoji(changeset) do
	emojified_fields = [:bio, :name, :raw_fields]

	if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
	bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
	name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))

	emoji = Map.merge(bio, name)

	emoji =
	changeset
	\|> get_field(:raw_fields)
	\|> Enum.reduce(emoji, fn x, acc ->
	Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
	end)

	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	with {:ok, value} <- fetch_change(changeset, map_field),
	{:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	{:error, :file_too_large} ->
	Ecto.Changeset.validate_change(changeset, map_field, fn map_field, _value ->
	[{map_field, "file is too large"}]
	end)

	_ ->
	changeset
	end
	end

	defp put_upload(value, type) do
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: type) do
	{:ok, object.data}
	end
	end

	def update_as_admin_changeset(struct, params) do
	struct
	\|> update_changeset(params)
	\|> cast(params, [:email])
	\|> delete_change(:also_known_as)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	end

	@spec update_as_admin(User.t(), map()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def update_as_admin(user, params) do
	params = Map.put(params, "password_confirmation", params["password"])
	changeset = update_as_admin_changeset(user, params)

	if params["password"] do
	reset_password(user, changeset, params)
	else
	User.update_and_set_cache(changeset)
	end
	end

	def password_update_changeset(struct, params) do
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> put_password_hash()
	\|> put_change(:password_reset_pending, false)
	end

	@spec reset_password(User.t(), map()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def reset_password(%User{} = user, params) do
	reset_password(user, user, params)
	end

	def reset_password(%User{id: user_id} = user, struct, params) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(struct, params))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

	case Repo.transaction(multi) do
	{:ok, %{user: user} = _} -> set_cache(user)
	{:error, _, changeset, _} -> {:error, changeset}
	end
	end

	def update_password_reset_pending(user, value) do
	user
	\|> change()
	\|> put_change(:password_reset_pending, value)
	\|> update_and_set_cache()
	end

	def force_password_reset_async(user) do
	BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	# Used to auto-register LDAP accounts which won't have a password hash stored locally
	def register_changeset_ldap(struct, params = %{password: password})
	when is_nil(password) do
	params = Map.put_new(params, :accepts_chat_messages, true)

	params =
	if Map.has_key?(params, :email) do
	Map.put_new(params, :email, params[:email])
	else
	params
	end

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	reason_limit = Config.get([:instance, :registration_reason_length], 500)
	params = Map.put_new(params, :accepts_chat_messages, true)

	confirmed? =
	if is_nil(opts[:confirmed]) do
	!Config.get([:instance, :account_activation_required])
	else
	opts[:confirmed]
	end

	approved? =
	if is_nil(opts[:approved]) do
	!Config.get([:instance, :account_approval_required])
	else
	opts[:approved]
	end

	struct
	\|> confirmation_changeset(set_confirmation: confirmed?)
	\|> approval_changeset(set_approval: approved?)
	\|> cast(params, [
	:bio,
	:raw_bio,
	:email,
	:name,
	:nickname,
	:password,
	:password_confirmation,
	:emoji,
	:accepts_chat_messages,
	:registration_reason,
	:birthday,
	:language
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_email_not_in_blacklisted_domain(:email)
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_length(:registration_reason, max: reason_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> maybe_validate_required_birthday
	\|> validate_min_age()
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def validate_not_restricted_nickname(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :restricted_nicknames])
	\|> Enum.all?(fn restricted_nickname ->
	String.downcase(value) != String.downcase(restricted_nickname)
	end)

	if valid?, do: [], else: [nickname: "Invalid nickname"]
	end)
	end

	def validate_email_not_in_blacklisted_domain(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	blacklisted_domain_downcase = String.downcase(blacklisted_domain)

	!String.ends_with?(String.downcase(value), [
	"@" <> blacklisted_domain_downcase,
	"." <> blacklisted_domain_downcase
	])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	end

	def maybe_validate_required_email(changeset, true), do: changeset

	def maybe_validate_required_email(changeset, _) do
	if Config.get([:instance, :account_activation_required]) do
	validate_required(changeset, [:email])
	else
	changeset
	end
	end

	defp maybe_validate_required_birthday(changeset) do
	if Config.get([:instance, :birthday_required]) do
	validate_required(changeset, [:birthday])
	else
	changeset
	end
	end

	defp validate_min_age(changeset) do
	changeset
	\|> validate_change(:birthday, fn :birthday, birthday ->
	valid? =
	Date.utc_today()
	\|> Date.diff(birthday) >=
	Config.get([:instance, :birthday_min_age])

	if valid?, do: [], else: [birthday: "Invalid age"]
	end)
	end

	defp put_ap_id(changeset) do
	ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :ap_id, ap_id)
	end

	defp put_following_and_follower_and_featured_address(changeset) do
	user = %User{nickname: get_field(changeset, :nickname)}
	followers = ap_followers(user)
	following = ap_following(user)
	featured = ap_featured_collection(user)

	changeset
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)
	\|> put_change(:featured_address, featured)
	end

	defp put_private_key(changeset) do
	{:ok, pem} = Keys.generate_rsa_pem()
	put_change(changeset, :keys, pem)
	end

	defp autofollow_users(user) do
	candidates = Config.get([:instance, :autofollowed_nicknames])

	autofollowed_users =
	User.Query.build(%{nickname: candidates, local: true, is_active: true})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

	defp autofollowing_users(user) do
	candidates = Config.get([:instance, :autofollowing_nicknames])

	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()
	\|> Enum.each(&follow(&1, user, :follow_accept))

	{:ok, :success}
	end

	@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
	def register(%Ecto.Changeset{} = changeset) do
	with {:ok, user} <- Repo.insert(changeset) do
	post_register_action(user)
	end
	end

	def post_register_action(%User{is_confirmed: false} = user) do
	with {:ok, _} <- maybe_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: false} = user) do
	with {:ok, _} <- send_user_approval_email(user),
	{:ok, _} <- send_admin_approval_emails(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, _} <- autofollowing_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- maybe_send_registration_email(user),
	{:ok, _} <- maybe_send_welcome_email(user),
	{:ok, _} <- maybe_send_welcome_message(user),
	{:ok, _} <- maybe_send_welcome_chat_message(user) do
	{:ok, user}
	end
	end

	defp send_user_approval_email(%User{email: email} = user) when is_binary(email) do
	user
	\|> Pleroma.Emails.UserEmail.approval_pending_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	end

	defp send_user_approval_email(_user) do
	{:ok, :skipped}
	end

	defp send_admin_approval_emails(user) do
	all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, :enqueued}
	end

	defp maybe_send_welcome_message(user) do
	if User.WelcomeMessage.enabled?() do
	User.WelcomeMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_chat_message(user) do
	if User.WelcomeChatMessage.enabled?() do
	User.WelcomeChatMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
	if User.WelcomeEmail.enabled?() do
	User.WelcomeEmail.send_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(_), do: {:ok, :noop}

	@spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued \| :noop}
	def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
	when is_binary(email) do
	if Config.get([:instance, :account_activation_required]) do
	send_confirmation_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

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

	@spec send_confirmation_email(Uset.t()) :: User.t()
	def send_confirmation_email(%User{} = user) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	user
	end

	@spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued \| :noop}
	defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
	with false <- User.WelcomeEmail.enabled?(),
	false <- Config.get([:instance, :account_activation_required], false),
	false <- Config.get([:instance, :account_approval_required], false) do
	user
	\|> Pleroma.Emails.UserEmail.successful_registration_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	_ ->
	{:ok, :noop}
	end
	end

	defp maybe_send_registration_email(_), do: {:ok, :noop}

	def needs_update?(%User{local: true}), do: false

	def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true

	def needs_update?(%User{local: false} = user) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
	end

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} \| {:error, String.t()}

	# "Locked" (self-locked) users demand explicit authorization of follow requests
	def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
	follow(follower, followed, :follow_pending)
	end

	def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
	follow(follower, followed)
	end

	def maybe_direct_follow(%User{} = follower, %User{} = followed) do
	- if not ap_enabled?(followed) do
	- follow(follower, followed)
	- else
	- {:ok, follower, followed}
	- end
	+ {:ok, follower, followed}
	end

	@doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
	@spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
	def follow_all(follower, followeds) do
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.each(&follow(follower, &1, :follow_accept))

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	cond do
	not followed.is_active ->
	{:error, "Could not follow user: #{followed.nickname} is deactivated."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	FollowingRelationship.follow(follower, followed, state)
	end
	end

	def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
	{:error, "Not subscribed!"}
	end

	@spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} \| {:error, String.t()}
	def unfollow(%User{} = follower, %User{} = followed) do
	case do_unfollow(follower, followed) do
	{:ok, follower, followed} ->
	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}

	error ->
	error
	end
	end

	@spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} \| {:error, String.t()}
	defp do_unfollow(%User{} = follower, %User{} = followed) do
	case get_follow_state(follower, followed) do
	state when state in [:follow_pending, :follow_accept] ->
	FollowingRelationship.unfollow(follower, followed)

	nil ->
	{:error, "Not subscribed!"}
	end
	end

	@doc "Returns follow state as Pleroma.FollowingRelationship.State value"
	def get_follow_state(%User{} = follower, %User{} = following) do
	following_relationship = FollowingRelationship.get(follower, following)
	get_follow_state(follower, following, following_relationship)
	end

	def get_follow_state(
	%User{} = follower,
	%User{} = following,
	following_relationship
	) do
	case {following_relationship, following.local} do
	{nil, false} ->
	case Utils.fetch_latest_follow(follower, following) do
	%Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
	FollowingRelationship.state_to_enum(state)

	_ ->
	nil
	end

	{%{state: state}, _} ->
	state

	{nil, _} ->
	nil
	end
	end

	def locked?(%User{} = user) do
	user.is_locked \|\| false
	end

	def get_by_id(id) do
	Repo.get_by(User, id: id)
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def get_by_uri(uri) do
	Repo.get_by(User, uri: uri)
	end

	def get_all_by_ap_id(ap_ids) do
	from(u in __MODULE__,
	where: u.ap_id in ^ap_ids
	)
	\|> Repo.all()
	end

	def get_all_by_ids(ids) do
	from(u in __MODULE__, where: u.id in ^ids)
	\|> Repo.all()
	end

	# This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
	# of the ap_id and the domain and tries to get that user
	def get_by_guessed_nickname(ap_id) do
	domain = URI.parse(ap_id).host
	name = List.last(String.split(ap_id, "/"))
	nickname = "#{name}@#{domain}"

	get_cached_by_nickname(nickname)
	end

	def set_cache({:ok, user}), do: set_cache(user)
	def set_cache({:error, err}), do: {:error, err}

	def set_cache(%User{} = user) do
	@cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	@cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	@cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
	{:ok, user}
	end

	def update_and_set_cache(struct, params) do
	struct
	\|> update_changeset(params)
	\|> update_and_set_cache()
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	end
	end

	def get_user_friends_ap_ids(user) do
	from(u in User.get_friends_query(user), select: u.ap_id)
	\|> Repo.all()
	end

	@spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
	def get_cached_user_friends_ap_ids(user) do
	@cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
	get_user_friends_ap_ids(user)
	end)
	end

	def invalidate_cache(user) do
	@cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	@cachex.del(:user_cache, "nickname:#{user.nickname}")
	@cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
	end

	@spec get_cached_by_ap_id(String.t()) :: User.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"

	with {:ok, nil} <- @cachex.get(:user_cache, key),
	user when not is_nil(user) <- get_by_ap_id(ap_id),
	{:ok, true} <- @cachex.put(:user_cache, key, user) do
	user
	else
	{:ok, user} -> user
	nil -> nil
	end
	end

	def get_cached_by_id(id) do
	key = "id:#{id}"

	ap_id =
	@cachex.fetch!(:user_cache, key, fn _ ->
	user = get_by_id(id)

	if user do
	@cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	{:commit, user.ap_id}
	else
	{:ignore, ""}
	end
	end)

	get_cached_by_ap_id(ap_id)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"

	@cachex.fetch!(:user_cache, key, fn _ ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

	@spec get_by_nickname(String.t()) :: User.t() \| nil
	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	Repo.get_by(User, nickname: local_nickname(nickname))
	end
	end

	def get_by_email(email), do: Repo.get_by(User, email: email)

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	end

	def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	{:ok, user}
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

	@spec get_followers_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_followers_query(%User{} = user, nil) do
	User.Query.build(%{followers: user, is_active: true})
	end

	def get_followers_query(%User{} = user, page) do
	user
	\|> get_followers_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_followers_query(User.t()) :: Ecto.Query.t()
	def get_followers_query(%User{} = user), do: get_followers_query(user, nil)

	@spec get_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

	@spec get_external_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_external_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	@spec get_friends_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_friends_query(%User{} = user, nil) do
	User.Query.build(%{friends: user, deactivated: false})
	end

	def get_friends_query(%User{} = user, page) do
	user
	\|> get_friends_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_friends_query(User.t()) :: Ecto.Query.t()
	def get_friends_query(%User{} = user), do: get_friends_query(user, nil)

	def get_friends(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ap_ids(%User{} = user) do
	user
	\|> get_friends_query(nil)
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end

	def get_friends_ids(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def update_note_count(%User{} = user, note_count \\ nil) do
	note_count =
	note_count \|\|
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)
	\|> Repo.one()

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

	@spec update_follower_count(User.t()) :: {:ok, User.t()}
	def update_follower_count(%User{} = user) do
	if user.local or !Config.get([:instance, :external_user_synchronization]) do
	follower_count = FollowingRelationship.follower_count(user)

	user
	\|> follow_information_changeset(%{follower_count: follower_count})
	\|> update_and_set_cache
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec update_following_count(User.t()) :: {:ok, User.t()}
	def update_following_count(%User{local: false} = user) do
	if Config.get([:instance, :external_user_synchronization]) do
	{:ok, maybe_fetch_follow_information(user)}
	else
	{:ok, user}
	end
	end

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> update_and_set_cache()
	end

	@spec get_users_from_set([String.t()], keyword()) :: [User.t()]
	def get_users_from_set(ap_ids, opts \\ []) do
	local_only = Keyword.get(opts, :local_only, true)
	criteria = %{ap_id: ap_ids, is_active: true}
	criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria

	User.Query.build(criteria)
	\|> Repo.all()
	end

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
	to = [actor \| to]

	query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})

	query
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), map()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
	notifications? = Map.get(params, :notifications, true)
	duration = Map.get(params, :duration, 0)

	expires_at =
	if duration > 0 do
	DateTime.utc_now()
	\|> DateTime.add(duration)
	else
	nil
	end

	with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee, expires_at),
	{:ok, user_notification_mute} <-
	(notifications? &&
	UserRelationship.create_notification_mute(
	muter,
	mutee,
	expires_at
	)) \|\|
	{:ok, nil} do
	if duration > 0 do
	Pleroma.Workers.MuteExpireWorker.enqueue(
	"unmute_user",
	%{"muter_id" => muter.id, "mutee_id" => mutee.id},
	scheduled_at: expires_at
	)
	end

	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")

	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(muter, mutee) do
	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def unmute(muter_id, mutee_id) do
	with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
	{:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
	unmute(muter, mutee)
	else
	{who, result} = error ->
	Logger.warn(
	"User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
	)

	{:error, error}
	end
	end

	def subscribe(%User{} = subscriber, %User{} = target) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

	def block(%User{} = blocker, %User{} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	# clear any requested follows from both sides as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	blocker =
	case CommonAPI.reject_follow_request(blocker, blocked) do
	{:ok, %User{} = updated_blocker} -> updated_blocker
	nil -> blocker
	end

	unsubscribe(blocked, blocker)

	unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
	if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
	add_to_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def block(%User{} = blocker, %{ap_id: ap_id}) do
	block(blocker, get_cached_by_ap_id(ap_id))
	end

	def unblock(%User{} = blocker, %User{} = blocked) do
	remove_from_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def unblock(%User{} = blocker, %{ap_id: ap_id}) do
	unblock(blocker, get_cached_by_ap_id(ap_id))
	end

	def endorse(%User{} = endorser, %User{} = target) do
	with max_endorsed_users <- Pleroma.Config.get([:instance, :max_endorsed_users], 0),
	endorsed_users <-
	User.endorsed_users_relation(endorser)
	\|> Repo.aggregate(:count, :id) do
	cond do
	endorsed_users >= max_endorsed_users ->
	{:error, "You have already pinned the maximum number of users"}

	not following?(endorser, target) ->
	{:error, "Could not endorse: You are not following #{target.nickname}"}

	true ->
	UserRelationship.create_endorsement(endorser, target)
	end
	end
	end

	def endorse(%User{} = endorser, %{ap_id: ap_id}) do
	with %User{} = endorsed <- get_cached_by_ap_id(ap_id) do
	endorse(endorser, endorsed)
	end
	end

	def unendorse(%User{} = unendorser, %User{} = target) do
	UserRelationship.delete_endorsement(unendorser, target)
	end

	def unendorse(%User{} = unendorser, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unendorse(unendorser, user)
	end
	end

	def mutes?(nil, _), do: false
	def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)

	def mutes_user?(%User{} = user, %User{} = target) do
	UserRelationship.mute_exists?(user, target)
	end

	@spec muted_notifications?(User.t() \| nil, User.t() \| map()) :: boolean()
	def muted_notifications?(nil, _), do: false

	def muted_notifications?(%User{} = user, %User{} = target),
	do: UserRelationship.notification_mute_exists?(user, target)

	def blocks?(nil, _), do: false

	def blocks?(%User{} = user, %User{} = target) do
	blocks_user?(user, target) \|\|
	(blocks_domain?(user, target) and not User.following?(user, target))
	end

	def blocks_user?(%User{} = user, %User{} = target) do
	UserRelationship.block_exists?(user, target)
	end

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

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
	%{host: host} = URI.parse(target.ap_id)
	Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
	end

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

	def subscribed_to?(%User{} = user, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.inverse_subscription_exists?(target, user)
	end

	def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	subscribed_to?(user, target)
	end
	end

	def endorses?(%User{} = user, %User{} = target) do
	UserRelationship.endorsement_exists?(user, target)
	end

	@doc """
	Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
	E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
	"""
	@spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
	def outgoing_relationships_ap_ids(_user, []), do: %{}

	def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}

	def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
	when is_list(relationship_types) do
	db_result =
	user
	\|> assoc(:outgoing_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :target))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
	\|> group_by([user_rel, u], user_rel.relationship_type)
	\|> Repo.all()
	\|> Enum.into(%{}, fn [k, v] -> {k, v} end)

	Enum.into(
	relationship_types,
	%{},
	fn rel_type -> {rel_type, db_result[rel_type] \|\| []} end
	)
	end

	def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)

	def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
	when is_list(relationship_types) do
	user
	\|> assoc(:incoming_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :source))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> maybe_filter_on_ap_id(ap_ids)
	\|> select([user_rel, u], u.ap_id)
	\|> distinct(true)
	\|> Repo.all()
	end

	defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
	where(query, [user_rel, u], u.ap_id in ^ap_ids)
	end

	defp maybe_filter_on_ap_id(query, _ap_ids), do: query

	def set_activation_async(user, status \\ true) do
	BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
	end

	@spec set_activation([User.t()], boolean()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def set_activation(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users, do: set_activation(user, status)
	end)
	end

	@spec set_activation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def set_activation(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&set_cache(update_following_count(&1)))

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&do_unfollow(user, &1))

	{:ok, user}
	end
	end

	def approve(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- approve(user), do: user
	end)
	end)
	end

	def approve(%User{is_approved: false} = user) do
	with chg <- change(user, is_approved: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def approve(%User{} = user), do: {:ok, user}

	def confirm(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- confirm(user), do: user
	end)
	end)
	end

	def confirm(%User{is_confirmed: false} = user) do
	with chg <- confirmation_changeset(user, set_confirmation: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def confirm(%User{} = user), do: {:ok, user}

	def set_suggestion(users, is_suggested) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- set_suggestion(user, is_suggested), do: user
	end)
	end)
	end

	def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}

	def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
	user
	\|> change(is_suggested: is_suggested)
	\|> update_and_set_cache()
	end

	def update_notification_settings(%User{} = user, settings) do
	user
	\|> cast(%{notification_settings: settings}, [])
	\|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	@spec purge_user_changeset(User.t()) :: Changeset.t()
	def purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	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,
	password_reset_pending: false,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	- ap_enabled: false,
	is_moderator: false,
	is_admin: false,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	# id: preserved
	# ap_id: preserved
	# nickname: preserved
	})
	end

	# Purge doesn't delete the user from the database.
	# It just nulls all its fields and deactivates it.
	# See `User.purge_user_changeset/1` above.
	defp purge(%User{} = user) do
	user
	\|> purge_user_changeset()
	\|> update_and_set_cache()
	end

	def delete(users) when is_list(users) do
	for user <- users, do: delete(user)
	end

	def delete(%User{} = user) do
	# Purge the user immediately
	purge(user)
	BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	# Actually delete the user from the DB
	defp delete_from_db(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	# If the user never finalized their account, it's safe to delete them.
	defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(user), do: {:ok, user}

	def perform(:force_password_reset, user), do: force_password_reset(user)

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	# Purge the user again, in case perform/2 is called directly
	purge(user)

	# Remove all relationships
	user
	\|> get_followers()
	\|> Enum.each(fn follower ->
	ActivityPub.unfollow(follower, user)
	unfollow(follower, user)
	end)

	user
	\|> get_friends()
	\|> Enum.each(fn followed ->
	ActivityPub.unfollow(user, followed)
	unfollow(user, followed)
	end)

	delete_user_activities(user)
	delete_notifications_from_user_activities(user)
	delete_outgoing_pending_follow_requests(user)

	maybe_delete_from_db(user)
	end

	def perform(:set_activation_async, user, status), do: set_activation(user, status)

	@spec external_users_query() :: Ecto.Query.t()
	def external_users_query do
	User.Query.build(%{
	external: true,
	active: true,
	order_by: :id
	})
	end

	@spec external_users(keyword()) :: [User.t()]
	def external_users(opts \\ []) do
	query =
	external_users_query()
	\|> select([u], struct(u, [:id, :ap_id]))

	query =
	if opts[:max_id],
	do: where(query, [u], u.id > ^opts[:max_id]),
	else: query

	query =
	if opts[:limit],
	do: limit(query, ^opts[:limit]),
	else: query

	Repo.all(query)
	end

	def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
	Notification
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> where([n, a], fragment("? = ?", a.actor, ^ap_id))
	\|> Repo.delete_all()
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.chunk_stream(50, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity -> delete_activity(activity, user) end)
	end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
	with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
	{:ok, delete_data, _} <- Builder.delete(user, object) do
	Pipeline.common_pipeline(delete_data, local: user.local)
	else
	{:find_object, nil} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete_activity(activity, user)
	end

	e ->
	Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
	Logger.error("Error: #{inspect(e)}")
	end
	end

	defp delete_activity(%{data: %{"type" => type}} = activity, user)
	when type in ["Like", "Announce"] do
	{:ok, undo, _} = Builder.undo(user, activity)
	Pipeline.common_pipeline(undo, local: user.local)
	end

	defp delete_activity(_activity, _user), do: "Doing nothing"

	defp delete_outgoing_pending_follow_requests(user) do
	user
	\|> FollowingRelationship.outgoing_pending_follow_requests_query()
	\|> Repo.delete_all()
	end

	def html_filter_policy(%User{no_rich_text: true}) do
	Pleroma.HTML.Scrubber.TwitterText
	end

	def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])

	def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)

	def get_or_fetch_by_ap_id(ap_id) do
	cached_user = get_cached_by_ap_id(ap_id)

	maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)

	case {cached_user, maybe_fetched_user} do
	{_, {:ok, %User{} = user}} ->
	{:ok, user}

	{%User{} = user, _} ->
	{:ok, user}

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

	@doc """
	Creates an internal service actor by URI if missing.
	Optionally takes nickname for addressing.
	"""
	@spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() \| nil
	def get_or_create_service_actor_by_ap_id(uri, nickname) do
	{_, user} =
	case get_cached_by_ap_id(uri) do
	nil ->
	with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
	Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
	{:error, nil}
	end

	%User{invisible: false} = user ->
	set_invisible(user)

	user ->
	{:ok, user}
	end

	user
	end

	@spec set_invisible(User.t()) :: {:ok, User.t()}
	defp set_invisible(user) do
	user
	\|> change(%{invisible: true})
	\|> update_and_set_cache()
	end

	@spec create_service_actor(String.t(), String.t()) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	defp create_service_actor(uri, nickname) do
	%User{
	invisible: true,
	local: true,
	ap_id: uri,
	nickname: nickname,
	follower_address: uri <> "/followers"
	}
	\|> change
	\|> put_private_key()
	\|> unique_constraint(:nickname)
	\|> Repo.insert()
	\|> set_cache()
	end

	def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	def public_key(_), do: {:error, "key not found"}

	def get_public_key_for_ap_id(ap_id) do
	with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
	{:ok, public_key} <- public_key(user) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	- def ap_enabled?(%User{local: true}), do: true
	- def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
	- def ap_enabled?(_), do: false
	-
	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def get_or_fetch("http://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch("https://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def parse_bio(bio) when is_binary(bio) and bio != "" do
	bio
	\|> CommonUtils.format_input("text/plain", mentions_format: :full)
	\|> elem(0)
	end

	def parse_bio(_), do: ""

	def parse_bio(bio, user) when is_binary(bio) and bio != "" do
	# TODO: get profile URLs other than user.ap_id
	profile_urls = [user.ap_id]

	bio
	\|> CommonUtils.format_input("text/plain",
	mentions_format: :full,
	rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
	)
	\|> elem(0)
	end

	def parse_bio(_, _), do: ""

	def tag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
	end)
	end

	def tag(nickname, tags) when is_binary(nickname),
	do: tag(get_by_nickname(nickname), tags)

	def tag(%User{} = user, tags),
	do: update_tags(user, Enum.uniq((user.tags \|\| []) ++ normalize_tags(tags)))

	def untag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
	end)
	end

	def untag(nickname, tags) when is_binary(nickname),
	do: untag(get_by_nickname(nickname), tags)

	def untag(%User{} = user, tags),
	do: update_tags(user, (user.tags \|\| []) -- normalize_tags(tags))

	defp update_tags(%User{} = user, new_tags) do
	{:ok, updated_user} =
	user
	\|> change(%{tags: new_tags})
	\|> update_and_set_cache()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase/1)
	end

	defp local_nickname_regex do
	if Config.get([:instance, :extended_nickname_format]) do
	@extended_local_nickname_regex
	else
	@strict_local_nickname_regex
	end
	end

	def local_nickname(nickname_or_mention) do
	nickname_or_mention
	\|> full_nickname()
	\|> String.split("@")
	\|> hd()
	end

	def full_nickname(%User{} = user) do
	if String.contains?(user.nickname, "@") do
	user.nickname
	else
	%{host: host} = URI.parse(user.ap_id)
	user.nickname <> "@" <> host
	end
	end

	def full_nickname(nickname_or_mention),
	do: String.trim_leading(nickname_or_mention, "@")

	def error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	@spec all_superusers() :: [User.t()]
	def all_superusers do
	User.Query.build(%{super_users: true, local: true, is_active: true})
	\|> Repo.all()
	end

	@spec all_users_with_privilege(atom()) :: [User.t()]
	def all_users_with_privilege(privilege) do
	User.Query.build(%{is_privileged: privilege}) \|> Repo.all()
	end

	def muting_reblogs?(%User{} = user, %User{} = target) do
	UserRelationship.reblog_mute_exists?(user, target)
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	not muting_reblogs?(user, target)
	end

	@doc """
	The function returns a query to get users with no activity for given interval of days.
	Inactive users are those who didn't read any notification, or had any activity where
	the user is the activity's actor, during `inactivity_threshold` days.
	Deactivated users will not appear in this list.

	## Examples

	iex> Pleroma.User.list_inactive_users()
	%Ecto.Query{}
	"""
	@spec list_inactive_users_query(integer()) :: Ecto.Query.t()
	def list_inactive_users_query(inactivity_threshold \\ 7) do
	negative_inactivity_threshold = -inactivity_threshold
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	# Subqueries are not supported in `where` clauses, join gets too complicated.
	has_read_notifications =
	from(n in Pleroma.Notification,
	where: n.seen == true,
	group_by: n.id,
	having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
	select: n.user_id
	)
	\|> Pleroma.Repo.all()

	from(u in Pleroma.User,
	left_join: a in Pleroma.Activity,
	on: u.ap_id == a.actor,
	where: not is_nil(u.nickname),
	where: u.is_active == ^true,
	where: u.id not in ^has_read_notifications,
	group_by: u.id,
	having:
	max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
	is_nil(max(a.inserted_at))
	)
	end

	@doc """
	Enable or disable email notifications for user

	## Examples

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
	Pleroma.User{email_notifications: %{"digest" => true}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
	Pleroma.User{email_notifications: %{"digest" => false}}
	"""
	@spec switch_email_notifications(t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, Ecto.Changeset.t()}
	def switch_email_notifications(user, type, status) do
	User.update_email_notifications(user, %{type => status})
	end

	@doc """
	Set `last_digest_emailed_at` value for the user to current time
	"""
	@spec touch_last_digest_emailed_at(t()) :: t()
	def touch_last_digest_emailed_at(user) do
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	{:ok, updated_user} =
	user
	\|> change(%{last_digest_emailed_at: now})
	\|> update_and_set_cache()

	updated_user
	end

	@spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def set_confirmation(%User{} = user, bool) do
	user
	\|> confirmation_changeset(set_confirmation: bool)
	\|> update_and_set_cache()
	end

	def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
	mascot
	end

	def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
	# use instance-default
	config = Config.get([:assets, :mascots])
	default_mascot = Config.get([:assets, :default_mascot])
	mascot = Keyword.get(config, default_mascot)

	%{
	"id" => "default-mascot",
	"url" => mascot[:url],
	"preview_url" => mascot[:url],
	"pleroma" => %{
	"mime_type" => mascot[:mime_type]
	}
	}
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	order_by: fragment("array_position(?, ?)", ^nicknames, u.nickname),
	select: u.ap_id
	)
	\|> Repo.all()
	end

	defp put_password_hash(
	%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
	) do
	change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
	end

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false

	# A hack because user delete activities have a fake id for whatever reason
	# TODO: Get rid of this
	def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []

	def get_delivered_users_by_object_id(object_id) do
	from(u in User,
	inner_join: delivery in assoc(u, :deliveries),
	where: delivery.object_id == ^object_id
	)
	\|> Repo.all()
	end

	def change_email(user, email) do
	user
	\|> cast(%{email: email}, [:email])
	\|> maybe_validate_required_email(false)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	def alias_users(user) do
	user.also_known_as
	\|> Enum.map(&User.get_cached_by_ap_id/1)
	\|> Enum.filter(fn user -> user != nil end)
	end

	def add_alias(user, new_alias_user) do
	current_aliases = user.also_known_as \|\| []
	new_alias_ap_id = new_alias_user.ap_id

	if new_alias_ap_id in current_aliases do
	{:ok, user}
	else
	user
	\|> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	end
	end

	def delete_alias(user, alias_user) do
	current_aliases = user.also_known_as \|\| []
	alias_ap_id = alias_user.ap_id

	if alias_ap_id in current_aliases do
	user
	\|> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	else
	{:error, :no_such_alias}
	end
	end

	# Internal function; public one is `deactivate/2`
	defp set_activation_status(user, status) do
	user
	\|> cast(%{is_active: status}, [:is_active])
	\|> update_and_set_cache()
	end

	def update_banner(user, banner) do
	user
	\|> cast(%{banner: banner}, [:banner])
	\|> update_and_set_cache()
	end

	def update_background(user, background) do
	user
	\|> cast(%{background: background}, [:background])
	\|> update_and_set_cache()
	end

	def validate_fields(changeset, remote? \\ false) do
	limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
	limit = Config.get([:instance, limit_name], 0)

	changeset
	\|> validate_length(:fields, max: limit)
	\|> validate_change(:fields, fn :fields, fields ->
	if Enum.all?(fields, &valid_field?/1) do
	[]
	else
	[fields: "invalid"]
	end
	end)
	end

	defp valid_field?(%{"name" => name, "value" => value}) do
	name_limit = Config.get([:instance, :account_field_name_length], 255)
	value_limit = Config.get([:instance, :account_field_value_length], 255)

	is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
	String.length(value) <= value_limit
	end

	defp valid_field?(_), do: false

	defp truncate_field(%{"name" => name, "value" => value}) do
	{name, _chopped} =
	String.split_at(name, Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Config.get([:instance, :account_field_value_length], 255))

	%{"name" => name, "value" => value}
	end

	def admin_api_update(user, params) do
	user
	\|> cast(params, [
	:is_moderator,
	:is_admin,
	:show_role
	])
	\|> update_and_set_cache()
	end

	@doc "Signs user out of all applications"
	def global_sign_out(user) do
	OAuth.Authorization.delete_user_authorizations(user)
	OAuth.Token.delete_user_tokens(user)
	end

	def mascot_update(user, url) do
	user
	\|> cast(%{mascot: url}, [:mascot])
	\|> validate_required([:mascot])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
	def confirmation_changeset(user, set_confirmation: confirmed?) do
	params =
	if confirmed? do
	%{
	is_confirmed: true,
	confirmation_token: nil
	}
	else
	%{
	is_confirmed: false,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	end

	cast(user, params, [:is_confirmed, :confirmation_token])
	end

	@spec approval_changeset(User.t(), keyword()) :: Changeset.t()
	def approval_changeset(user, set_approval: approved?) do
	cast(user, %{is_approved: approved?}, [:is_approved])
	end

	@spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} \| {:error, term()}
	def add_pinned_object_id(%User{} = user, object_id) do
	if !user.pinned_objects[object_id] do
	params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}

	user
	\|> cast(params, [:pinned_objects])
	\|> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)

	if Enum.count(pinned_objects) <= max_pinned_statuses do
	[]
	else
	[pinned_objects: "You have already pinned the maximum number of statuses"]
	end
	end)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	@spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} \| {:error, term()}
	def remove_pinned_object_id(%User{} = user, object_id) do
	user
	\|> cast(
	%{pinned_objects: Map.delete(user.pinned_objects, object_id)},
	[:pinned_objects]
	)
	\|> update_and_set_cache()
	end

	def update_email_notifications(user, settings) do
	email_notifications =
	user.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

	params = %{email_notifications: email_notifications}
	fields = [:email_notifications]

	user
	\|> cast(params, fields)
	\|> validate_required(fields)
	\|> update_and_set_cache()
	end

	defp set_domain_blocks(user, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	user
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	\|> update_and_set_cache()
	end

	def block_domain(user, domain_blocked) do
	set_domain_blocks(user, Enum.uniq([domain_blocked \| user.domain_blocks]))
	end

	def unblock_domain(user, domain_blocked) do
	set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	def set_invisible(user, invisible) do
	params = %{invisible: invisible}

	user
	\|> cast(params, [:invisible])
	\|> validate_required([:invisible])
	\|> update_and_set_cache()
	end

	def sanitize_html(%User{} = user) do
	sanitize_html(user, nil)
	end

	# User data that mastodon isn't filtering (treated as plaintext):
	# - field name
	# - display name
	def sanitize_html(%User{} = user, filter) do
	fields =
	Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
	%{
	"name" => name,
	"value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
	}
	end)

	user
	\|> Map.put(:bio, HTML.filter_tags(user.bio, filter))
	\|> Map.put(:fields, fields)
	end

	def get_host(%User{ap_id: ap_id} = _user) do
	URI.parse(ap_id).host
	end

	def update_last_active_at(%__MODULE__{local: true} = user) do
	user
	\|> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
	\|> update_and_set_cache()
	end

	def active_user_count(days \\ 30) do
	active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)

	__MODULE__
	\|> where([u], u.last_active_at >= ^active_after)
	\|> where([u], u.local == true)
	\|> Repo.aggregate(:count)
	end

	def update_last_status_at(user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], set: [last_status_at: fragment("NOW()")])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def get_friends_birthdays_query(%User{} = user, day, month) do
	User.Query.build(%{
	friends: user,
	deactivated: false,
	birthday_day: day,
	birthday_month: month
	})
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index f22756015..1a10aef1d 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1806 +1,1801 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Hashtag
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker
	alias Pleroma.Workers.PollWorker

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility

	require Logger
	require Pleroma.Constants

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

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

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

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

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

	defp check_actor_can_insert(_), do: true

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

	defp check_remote_limit(_), do: true

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

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

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

	defp increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if is_public?(object) do
	Object.increase_replies_count(reply_ap_id)
	end
	end

	defp increase_replies_count_if_reply(_create_data), do: :noop

	@object_types ~w[ChatMessage Question Answer Audio Video Image Event Article Note Page]
	@impl true
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

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

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

	ConcurrentLimiter.limit(Pleroma.Web.RichMedia.Helpers, fn ->
	Task.start(fn -> Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) end)
	end)

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

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

	{:containment, _} = error ->
	error

	{:error, _} = error ->
	error

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

	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	{:ok, activity}

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

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

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

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

	def notify_and_stream(activity) do
	Notification.create_notifications(activity)

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

	_ ->
	activity
	end

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

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

	defp maybe_create_activity_expiration(activity), do: {:ok, activity}

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

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

	defp get_participations(_), do: []

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

	Streamer.stream("participation", participations)
	end

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

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

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

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

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

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

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

	defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]
	quick_insert? = Config.get([:env]) == :benchmark

	create_data =
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	{:ok, _actor} <- update_last_status_at_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_schedule_poll_notifications(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	Repo.rollback(message)
	end
	end

	defp maybe_schedule_poll_notifications(activity) do
	PollWorker.schedule_poll_end(activity)
	:ok
	end

	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

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

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

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

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

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

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

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

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

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

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

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

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

	BackgroundWorker.enqueue("move_following", %{
	"origin_id" => origin.id,
	"target_id" => target.id
	})

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

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

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

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

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

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

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

	Pagination.fetch_paginated(query, opts, pagination)
	end

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

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

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

	opts = Map.delete(opts, :user)

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

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

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

	@valid_visibilities ~w[direct unlisted public private]

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

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

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

	defp restrict_visibility(query, _visibility), do: query

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

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

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

	defp exclude_visibility(query, _visibility), do: query

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	defp restrict_announce_object_actor(query, _), do: query

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

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

	defp restrict_since(query, _), do: query

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

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

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

	defp restrict_embedded_tag_all(query, _), do: query

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

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

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

	defp restrict_embedded_tag_any(query, _), do: query

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

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

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

	defp restrict_embedded_tag_reject_any(query, _), do: query

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

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

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

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

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

	defp restrict_hashtag_all(query, _), do: query

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

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

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

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

	defp restrict_hashtag_any(query, _), do: query

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

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

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

	defp restrict_hashtag_reject_any(query, _), do: query

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

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

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

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

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

	defp restrict_local(query, _), do: query

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

	defp restrict_remote(query, _), do: query

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

	defp restrict_actor(query, _), do: query

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

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

	defp restrict_type(query, _), do: query

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

	defp restrict_state(query, _), do: query

	defp restrict_favorited_by(query, %{favorited_by: ap_id}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
	)
	end

	defp restrict_favorited_by(query, _), do: query

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

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

	defp restrict_media(query, _), do: query

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

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

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

	defp restrict_replies(query, _), do: query

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

	defp restrict_reblogs(query, _), do: query

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

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

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

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

	defp restrict_muted(query, _), do: query

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

	following_ap_ids = User.get_friends_ap_ids(user)

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

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

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

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

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

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

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

	defp restrict_blocked(query, _), do: query

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

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

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

	defp restrict_blockers_visibility(query, _), do: query

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

	defp restrict_unlisted(query, _), do: query

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

	defp restrict_pinned(query, _), do: query

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

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

	defp restrict_muted_reblogs(query, _), do: query

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

	defp restrict_instance(query, _), do: query

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

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

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

	defp restrict_filtered(query, _), do: query

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

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

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

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

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

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

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

	defp exclude_id(query, _), do: query

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

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

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

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

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

	defp maybe_preload_report_notes(query, _), do: query

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

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

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

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

	defp maybe_order(query, _), do: query

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

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

	Map.put(opts, key, normalized_value)

	_ ->
	opts
	end
	end)
	end

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

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

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

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

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

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

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

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

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

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

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

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

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

	activity ->
	activity
	end)
	end

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

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

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

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

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

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

	defp sanitize_upload_file(upload), do: upload

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

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

	defp get_actor_url(_url), do: nil

	defp normalize_image(%{"url" => url}) do
	%{
	"type" => "Image",
	"url" => [%{"href" => url}]
	}
	end

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

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

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

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

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

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

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

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

	show_birthday = !!birthday

	# if WebFinger request was already done, we probably have acct, otherwise
	# we request WebFinger here
	nickname = additional[:nickname_from_acct] \|\| generate_nickname(data)

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

	defp generate_nickname(%{"preferredUsername" => username} = data) when is_binary(username) do
	generated = "#{username}@#{URI.parse(data["id"]).host}"

	if Config.get([WebFinger, :update_nickname_on_user_fetch]) do
	case WebFinger.finger(generated) do
	{:ok, %{"subject" => "acct:" <> acct}} -> acct
	_ -> generated
	end
	else
	generated
	end
	end

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

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

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

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

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

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

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

	user_data
	end
	end

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

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

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

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

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

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

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

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

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

	_ ->
	nil
	end
	end

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

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

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

	def pinned_fetch_task(nil), do: nil

	def pinned_fetch_task(%{pinned_objects: pins}) do
	if Enum.all?(pins, fn {ap_id, _} ->
	Object.get_cached_by_ap_id(ap_id) \|\|
	match?({:ok, _object}, Fetcher.fetch_object_from_id(ap_id))
	end) do
	:ok
	else
	:error
	end
	end

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

	- if user && !User.ap_enabled?(user) do
	- Transmogrifier.upgrade_user_from_ap_id(ap_id)
	- else
	- with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	- {:ok, _pid} = Task.start(fn -> pinned_fetch_task(data) end)
	+ with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	+ {:ok, _pid} = Task.start(fn -> pinned_fetch_task(data) end)

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

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

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

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

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

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

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

	defp maybe_restrict_deactivated_users(activity, _opts),
	do: Activity.restrict_deactivated_users(activity)
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex b/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex
	index 5202db7f1..db3259550 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex
	@@ -1,78 +1,79 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AddRemoveValidator do
	use Ecto.Schema

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

	require Pleroma.Constants

	alias Pleroma.User

	@primary_key false

	embedded_schema do
	field(:target)

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

	def cast_and_validate(data) do
	{:ok, actor} = User.get_or_fetch_by_ap_id(data["actor"])

	{:ok, actor} = maybe_refetch_user(actor)

	data
	\|> maybe_fix_data_for_mastodon(actor)
	\|> cast_data()
	\|> validate_data(actor)
	end

	defp maybe_fix_data_for_mastodon(data, actor) do
	# Mastodon sends pin/unpin objects without id, to, cc fields
	data
	\|> Map.put_new("id", Pleroma.Web.ActivityPub.Utils.generate_activity_id())
	\|> Map.put_new("to", [Pleroma.Constants.as_public()])
	\|> Map.put_new("cc", [actor.follower_address])
	end

	defp cast_data(data) do
	cast(%__MODULE__{}, data, __schema__(:fields))
	end

	defp validate_data(changeset, actor) do
	changeset
	\|> validate_required([:id, :target, :object, :actor, :type, :to, :cc])
	\|> validate_inclusion(:type, ~w(Add Remove))
	\|> validate_actor_presence()
	\|> validate_collection_belongs_to_actor(actor)
	\|> validate_object_presence()
	end

	defp validate_collection_belongs_to_actor(changeset, actor) do
	validate_change(changeset, :target, fn :target, target ->
	if target == actor.featured_address do
	[]
	else
	[target: "collection doesn't belong to actor"]
	end
	end)
	end

	defp maybe_refetch_user(%User{featured_address: address} = user) when is_binary(address) do
	{:ok, user}
	end

	defp maybe_refetch_user(%User{ap_id: ap_id}) do
	- Pleroma.Web.ActivityPub.Transmogrifier.upgrade_user_from_ap_id(ap_id)
	+ # Maybe it could use User.get_or_fetch_by_ap_id to avoid refreshing too often
	+ User.fetch_by_ap_id(ap_id)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
	index 6c1ba76a3..af6aa0781 100644
	--- a/lib/pleroma/web/activity_pub/publisher.ex
	+++ b/lib/pleroma/web/activity_pub/publisher.ex
	@@ -1,281 +1,279 @@
	# 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.Publisher do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Delivery
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier

	require Pleroma.Constants

	import Pleroma.Web.ActivityPub.Visibility

	@behaviour Pleroma.Web.Federator.Publisher

	require Logger

	@moduledoc """
	ActivityPub outgoing federation module.
	"""

	@doc """
	Determine if an activity can be represented by running it through Transmogrifier.
	"""
	def is_representable?(%Activity{} = activity) do
	with {:ok, _data} <- Transmogrifier.prepare_outgoing(activity.data) do
	true
	else
	_e ->
	false
	end
	end

	@doc """
	Publish a single message to a peer. Takes a struct with the following
	parameters set:

	* `inbox`: the inbox to publish to
	* `json`: the JSON message body representing the ActivityPub message
	* `actor`: the actor which is signing the message
	* `id`: the ActivityStreams URI of the message
	"""
	def publish_one(%{inbox: inbox, json: json, actor: %User{} = actor, id: id} = params) do
	Logger.debug("Federating #{id} to #{inbox}")
	uri = %{path: path} = URI.parse(inbox)
	digest = "SHA-256=" <> (:crypto.hash(:sha256, json) \|> Base.encode64())

	date = Pleroma.Signature.signed_date()

	signature =
	Pleroma.Signature.sign(actor, %{
	"(request-target)": "post #{path}",
	host: signature_host(uri),
	"content-length": byte_size(json),
	digest: digest,
	date: date
	})

	with {:ok, %{status: code}} = result when code in 200..299 <-
	HTTP.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"Date", date},
	{"signature", signature},
	{"digest", digest}
	]
	) do
	if not Map.has_key?(params, :unreachable_since) \|\| params[:unreachable_since] do
	Instances.set_reachable(inbox)
	end

	result
	else
	{_post_result, response} ->
	unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
	{:error, response}
	end
	end

	def publish_one(%{actor_id: actor_id} = params) do
	actor = User.get_cached_by_id(actor_id)

	params
	\|> Map.delete(:actor_id)
	\|> Map.put(:actor, actor)
	\|> publish_one()
	end

	defp signature_host(%URI{port: port, scheme: scheme, host: host}) do
	if port == URI.default_port(scheme) do
	host
	else
	"#{host}:#{port}"
	end
	end

	defp should_federate?(inbox, public) do
	if public do
	true
	else
	%{host: host} = URI.parse(inbox)

	quarantined_instances =
	Config.get([:instance, :quarantined_instances], [])
	\|> Pleroma.Web.ActivityPub.MRF.instance_list_from_tuples()
	\|> Pleroma.Web.ActivityPub.MRF.subdomains_regex()

	!Pleroma.Web.ActivityPub.MRF.subdomain_match?(quarantined_instances, host)
	end
	end

	@spec recipients(User.t(), Activity.t()) :: list(User.t()) \| []
	defp recipients(actor, activity) do
	followers =
	if actor.follower_address in activity.recipients do
	User.get_external_followers(actor)
	else
	[]
	end

	fetchers =
	with %Activity{data: %{"type" => "Delete"}} <- activity,
	%Object{id: object_id} <- Object.normalize(activity, fetch: false),
	fetchers <- User.get_delivered_users_by_object_id(object_id),
	_ <- Delivery.delete_all_by_object_id(object_id) do
	fetchers
	else
	_ ->
	[]
	end

	Pleroma.Web.Federator.Publisher.remote_users(actor, activity) ++ followers ++ fetchers
	end

	defp get_cc_ap_ids(ap_id, recipients) do
	host = Map.get(URI.parse(ap_id), :host)

	recipients
	\|> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
	\|> Enum.map(& &1.ap_id)
	end

	defp maybe_use_sharedinbox(%User{shared_inbox: nil, inbox: inbox}), do: inbox
	defp maybe_use_sharedinbox(%User{shared_inbox: shared_inbox}), do: shared_inbox

	@doc """
	Determine a user inbox to use based on heuristics. These heuristics
	are based on an approximation of the ``sharedInbox`` rules in the
	[ActivityPub specification][ap-sharedinbox].

	Please do not edit this function (or its children) without reading
	the spec, as editing the code is likely to introduce some breakage
	without some familiarity.

	[ap-sharedinbox]: https://www.w3.org/TR/activitypub/#shared-inbox-delivery
	"""
	def determine_inbox(
	%Activity{data: activity_data},
	%User{inbox: inbox} = user
	) do
	to = activity_data["to"] \|\| []
	cc = activity_data["cc"] \|\| []
	type = activity_data["type"]

	cond do
	type == "Delete" ->
	maybe_use_sharedinbox(user)

	Pleroma.Constants.as_public() in to \|\| Pleroma.Constants.as_public() in cc ->
	maybe_use_sharedinbox(user)

	length(to) + length(cc) > 1 ->
	maybe_use_sharedinbox(user)

	true ->
	inbox
	end
	end

	@doc """
	Publishes an activity with BCC to all relevant peers.
	"""

	def publish(%User{} = actor, %{data: %{"bcc" => bcc}} = activity)
	when is_list(bcc) and bcc != [] do
	public = is_public?(activity)
	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)

	recipients = recipients(actor, activity)

	inboxes =
	recipients
	- \|> Enum.filter(&User.ap_enabled?/1)
	\|> Enum.map(fn actor -> actor.inbox end)
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()

	Repo.checkout(fn ->
	Enum.each(inboxes, fn {inbox, unreachable_since} ->
	%User{ap_id: ap_id} = Enum.find(recipients, fn actor -> actor.inbox == inbox end)

	# Get all the recipients on the same host and add them to cc. Otherwise, a remote
	# instance would only accept a first message for the first recipient and ignore the rest.
	cc = get_cc_ap_ids(ap_id, recipients)

	json =
	data
	\|> Map.put("cc", cc)
	\|> Jason.encode!()

	Pleroma.Web.Federator.Publisher.enqueue_one(__MODULE__, %{
	inbox: inbox,
	json: json,
	actor_id: actor.id,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	})
	end)
	end)
	end

	# Publishes an activity to all relevant peers.
	def publish(%User{} = actor, %Activity{} = activity) do
	public = is_public?(activity)

	if public && Config.get([:instance, :allow_relay]) do
	Logger.debug(fn -> "Relaying #{activity.data["id"]} out" end)
	Relay.publish(activity)
	end

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	json = Jason.encode!(data)

	recipients(actor, activity)
	- \|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %User{} = user ->
	determine_inbox(activity, user)
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()
	\|> Enum.each(fn {inbox, unreachable_since} ->
	Pleroma.Web.Federator.Publisher.enqueue_one(
	__MODULE__,
	%{
	inbox: inbox,
	json: json,
	actor_id: actor.id,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	}
	)
	end)
	end

	def gather_webfinger_links(%User{} = user) do
	[
	%{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
	%{
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"href" => user.ap_id
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: ["activitypub"]
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 3141f8437..0e6c429f9 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,997 +1,955 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator
	- alias Pleroma.Workers.TransmogrifierWorker

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object, options \\ []) do
	object
	\|> strip_internal_fields()
	\|> fix_actor()
	\|> fix_url()
	\|> fix_attachments()
	\|> fix_context()
	\|> fix_in_reply_to(options)
	\|> fix_emoji()
	\|> fix_tag()
	\|> fix_content_map()
	\|> fix_addressing()
	\|> fix_summary()
	end

	def fix_summary(%{"summary" => nil} = object) do
	Map.put(object, "summary", "")
	end

	def fix_summary(%{"summary" => _} = object) do
	# summary is present, nothing to do
	object
	end

	def fix_summary(object), do: Map.put(object, "summary", "")

	def fix_addressing_list(map, field) do
	addrs = map[field]

	cond do
	is_list(addrs) ->
	Map.put(map, field, Enum.filter(addrs, &is_binary/1))

	is_binary(addrs) ->
	Map.put(map, field, [addrs])

	true ->
	Map.put(map, field, [])
	end
	end

	# if directMessage flag is set to true, leave the addressing alone
	def fix_explicit_addressing(%{"directMessage" => true} = object, _follower_collection),
	do: object

	def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, follower_collection) do
	explicit_mentions =
	Utils.determine_explicit_mentions(object) ++
	[Pleroma.Constants.as_public(), follower_collection]

	explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
	explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.filter(& &1)
	\|> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
	\|> Enum.uniq()

	object
	\|> Map.put("to", explicit_to)
	\|> Map.put("cc", final_cc)
	end

	# if as:Public is addressed, then make sure the followers collection is also addressed
	# so that the activities will be delivered to local users.
	def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
	recipients = to ++ cc

	if followers_collection not in recipients do
	cond do
	Pleroma.Constants.as_public() in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	Pleroma.Constants.as_public() in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_addressing(object) do
	{:ok, %User{follower_address: follower_collection}} =
	object
	\|> Containment.get_actor()
	\|> User.get_or_fetch_by_ap_id()

	object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	\|> fix_explicit_addressing(follower_collection)
	\|> fix_implicit_addressing(follower_collection)
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	actor = Containment.get_actor(%{"actor" => actor})

	# TODO: Remove actor field for Objects
	object
	\|> Map.put("actor", actor)
	\|> Map.put("attributedTo", actor)
	end

	def fix_in_reply_to(object, options \\ [])

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
	when not is_nil(in_reply_to) do
	in_reply_to_id = prepare_in_reply_to(in_reply_to)
	depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(depth) do
	with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.drop(["conversation", "inReplyToAtomUri"])
	else
	e ->
	Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
	object
	end
	else
	object
	end
	end

	def fix_in_reply_to(object, _options), do: object

	defp prepare_in_reply_to(in_reply_to) do
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	true ->
	""
	end
	end

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.drop(["conversation"])
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	Enum.map(attachment, fn data ->
	url =
	cond do
	is_list(data["url"]) -> List.first(data["url"])
	is_map(data["url"]) -> data["url"]
	true -> nil
	end

	media_type =
	cond do
	is_map(url) && url =~ Pleroma.Constants.mime_regex() ->
	url["mediaType"]

	is_bitstring(data["mediaType"]) && data["mediaType"] =~ Pleroma.Constants.mime_regex() ->
	data["mediaType"]

	is_bitstring(data["mimeType"]) && data["mimeType"] =~ Pleroma.Constants.mime_regex() ->
	data["mimeType"]

	true ->
	nil
	end

	href =
	cond do
	is_map(url) && is_binary(url["href"]) -> url["href"]
	is_binary(data["url"]) -> data["url"]
	is_binary(data["href"]) -> data["href"]
	true -> nil
	end

	if href do
	attachment_url =
	%{
	"href" => href,
	"type" => Map.get(url \|\| %{}, "type", "Link")
	}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("width", (url \|\| %{})["width"] \|\| data["width"])
	\|> Maps.put_if_present("height", (url \|\| %{})["height"] \|\| data["height"])

	%{
	"url" => [attachment_url],
	"type" => data["type"] \|\| "Document"
	}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("name", data["name"])
	\|> Maps.put_if_present("blurhash", data["blurhash"])
	else
	nil
	end
	end)
	\|> Enum.filter(& &1)

	Map.put(object, "attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	object
	\|> Map.put("attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	Map.put(object, "url", url["href"])
	end

	def fix_url(%{"url" => url} = object) when is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	Map.put(object, "url", url_string)
	end

	def fix_url(object), do: object

	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji =
	tags
	\|> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	Map.put(mapping, name, data["icon"]["url"])
	end)

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	name = String.trim(tag["name"], ":")
	emoji = %{name => tag["icon"]["url"]}

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	\|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	\|> Enum.map(fn
	%{"name" => "#" <> hashtag} -> String.downcase(hashtag)
	%{"name" => hashtag} -> String.downcase(hashtag)
	end)

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

	def fix_tag(%{"tag" => %{} = tag} = object) do
	object
	\|> Map.put("tag", [tag])
	\|> fix_tag
	end

	def fix_tag(object), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	Map.put(object, "content", content)
	end

	def fix_content_map(object), do: object

	defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
	when is_binary(reply_id) do
	options = Keyword.put(options, :fetch, true)

	with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
	Map.put(object, "type", "Answer")
	else
	_ -> object
	end
	end

	defp fix_type(object, _options), do: object

	# Reduce the object list to find the reported user.
	defp get_reported(objects) do
	Enum.reduce_while(objects, nil, fn ap_id, _ ->
	with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
	{:halt, user}
	else
	_ -> {:cont, nil}
	end
	end)
	end

	def handle_incoming(data, options \\ [])

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	# Reduce the object list to find the reported user.
	%User{} = account <- get_reported(objects),
	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	%{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{"cc" => [account.ap_id]}
	}
	\|> ActivityPub.flag()
	end
	end

	# disallow objects with bogus IDs
	def handle_incoming(%{"id" => nil}, _options), do: :error
	def handle_incoming(%{"id" => ""}, _options), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
	do: :error

	def handle_incoming(
	%{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
	options
	) do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	reply_depth = (options[:depth] \|\| 0) + 1
	options = Keyword.put(options, :depth, reply_depth)
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: nil,
	local: false,
	published: data["published"],
	additional: Map.take(data, ["cc", "id"])
	}

	ActivityPub.listen(params)
	else
	_e -> :error
	end
	end

	@misskey_reactions %{
	"like" => "👍",
	"love" => "❤️",
	"laugh" => "😆",
	"hmm" => "🤔",
	"surprise" => "😮",
	"congrats" => "🎉",
	"angry" => "💢",
	"confused" => "😥",
	"rip" => "😇",
	"pudding" => "🍮",
	"star" => "⭐"
	}

	@doc "Rewrite misskey likes into EmojiReacts"
	def handle_incoming(
	%{
	"type" => "Like",
	"_misskey_reaction" => reaction
	} = data,
	options
	) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", @misskey_reactions[reaction] \|\| reaction)
	\|> handle_incoming(options)
	end

	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
	options
	)
	when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note Page Image} do
	fetch_options = Keyword.put(options, :depth, (options[:depth] \|\| 0) + 1)

	object =
	data["object"]
	\|> strip_internal_fields()
	\|> fix_type(fetch_options)
	\|> fix_in_reply_to(fetch_options)

	data = Map.put(data, "object", object)
	options = Keyword.put(options, :local, false)

	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	nil <- Activity.get_create_by_object_ap_id(obj_id),
	{:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
	{:ok, activity}
	else
	%Activity{} = activity -> {:ok, activity}
	e -> e
	end
	end

	def handle_incoming(%{"type" => type} = data, _options)
	when type in ~w{Like EmojiReact Announce Add Remove} do
	with :ok <- ObjectValidator.fetch_actor_and_object(data),
	{:ok, activity, _meta} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	e -> {:error, e}
	end
	end

	def handle_incoming(
	%{"type" => type} = data,
	_options
	)
	when type in ~w{Update Block Follow Accept Reject} do
	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	{:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	def handle_incoming(
	%{"type" => "Delete"} = data,
	_options
	) do
	with {:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	{:error, {:validate, _}} = e ->
	# Check if we have a create activity for this
	with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
	%Activity{data: %{"actor" => actor}} <-
	Activity.create_by_object_ap_id(object_id) \|> Repo.one(),
	# We have one, insert a tombstone and retry
	{:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	handle_incoming(data)
	else
	_ -> e
	end
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data,
	_options
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	{:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => type}
	} = data,
	_options
	)
	when type in ["Like", "EmojiReact", "Announce", "Block"] do
	with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	# For Undos that don't have the complete object attached, try to find it in our database.
	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => object
	} = activity,
	options
	)
	when is_binary(object) do
	with %Activity{data: data} <- Activity.get_by_ap_id(object) do
	activity
	\|> Map.put("object", data)
	\|> handle_incoming(options)
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Move",
	"actor" => origin_actor,
	"object" => origin_actor,
	"target" => target_actor
	},
	_options
	) do
	with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
	true <- origin_actor in target_user.also_known_as do
	ActivityPub.move(origin_user, target_user, false)
	else
	_e -> :error
	end
	end

	def handle_incoming(_, _), do: :error

	@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} \| nil
	def get_obj_helper(id, options \\ []) do
	options = Keyword.put(options, :fetch, true)

	case Object.normalize(id, options) do
	%Object{} = object -> {:ok, object}
	_ -> nil
	end
	end

	@spec get_embedded_obj_helper(String.t() \| Object.t(), User.t()) :: {:ok, Object.t()} \| nil
	def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
	ap_id: ap_id
	})
	when attributed_to == ap_id do
	with {:ok, activity} <-
	handle_incoming(%{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => attributed_to,
	"object" => data
	}) do
	{:ok, Object.normalize(activity, fetch: false)}
	else
	_ -> get_obj_helper(object_id)
	end
	end

	def get_embedded_obj_helper(object_id, _) do
	get_obj_helper(object_id)
	end

	def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
	with false <- String.starts_with?(in_reply_to, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| in_reply_to)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	@doc """
	Serialized Mastodon-compatible `replies` collection containing _self-replies_.
	Based on Mastodon's ActivityPub::NoteSerializer#replies.
	"""
	def set_replies(obj_data) do
	replies_uris =
	with limit when limit > 0 <-
	Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
	%Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
	object
	\|> Object.self_replies()
	\|> select([o], fragment("?->>'id'", o.data))
	\|> limit(^limit)
	\|> Repo.all()
	else
	_ -> []
	end

	set_replies(obj_data, replies_uris)
	end

	defp set_replies(obj, []) do
	obj
	end

	defp set_replies(obj, replies_uris) do
	replies_collection = %{
	"type" => "Collection",
	"items" => replies_uris
	}

	Map.merge(obj, %{"replies" => replies_collection})
	end

	def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
	items
	end

	def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
	items
	end

	def replies(_), do: []

	# Prepares the object of an outgoing create activity.
	def prepare_object(object) do
	object
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> set_replies
	\|> strip_internal_fields
	\|> strip_internal_tags
	\|> set_type
	\|> maybe_process_history
	end

	defp maybe_process_history(%{"formerRepresentations" => %{"orderedItems" => history}} = object) do
	processed_history =
	Enum.map(
	history,
	fn
	item when is_map(item) -> prepare_object(item)
	item -> item
	end
	)

	put_in(object, ["formerRepresentations", "orderedItems"], processed_history)
	end

	defp maybe_process_history(object) do
	object
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
	when activity_type in ["Create", "Listen"] do
	object =
	object_id
	\|> Object.normalize(fetch: false)
	\|> Map.get(:data)
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Update", "object" => %{"type" => objtype} = object} = data)
	when objtype in Pleroma.Constants.updatable_object_types() do
	object =
	object
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
	object =
	object_id
	\|> Object.normalize(fetch: false)

	data =
	if Visibility.is_private?(object) && object.data["actor"] == ap_id do
	data \|> Map.put("object", object \|> Map.get(:data) \|> prepare_object)
	else
	data \|> maybe_fix_object_url
	end

	data =
	data
	\|> strip_internal_fields
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_outgoing(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> strip_internal_fields
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
	with false <- String.starts_with?(object, "http"),
	{:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
	%{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
	relative_object do
	Map.put(data, "object", external_url)
	else
	{:fetch, e} ->
	Logger.error("Couldn't fetch #{object} #{inspect(e)}")
	data

	_ ->
	data
	end
	end

	def maybe_fix_object_url(data), do: data

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn
	# Expand internal representation tags into AS2 tags.
	tag when is_binary(tag) ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}

	# Do not process tags which are already AS2 tag objects.
	tag when is_map(tag) ->
	tag
	end)

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

	# TODO These should be added on our side on insertion, it doesn't make much
	# sense to regenerate these all the time
	def add_mention_tags(object) do
	to = object["to"] \|\| []
	cc = object["cc"] \|\| []
	mentioned = User.get_users_from_set(to ++ cc, local_only: false)

	mentions = Enum.map(mentioned, &build_mention_tag/1)

	tags = object["tag"] \|\| []
	Map.put(object, "tag", tags ++ mentions)
	end

	defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
	%{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
	end

	def take_emoji_tags(%User{emoji: emoji}) do
	emoji
	\|> Map.to_list()
	\|> Enum.map(&build_emoji_tag/1)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(%{"emoji" => emoji} = object) do
	tags = object["tag"] \|\| []

	out = Enum.map(emoji, &build_emoji_tag/1)

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

	def add_emoji_tags(object), do: object

	defp build_emoji_tag({name, url}) do
	%{
	"icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_type(%{"type" => "Answer"} = object) do
	Map.put(object, "type", "Note")
	end

	def set_type(object), do: object

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]
	Map.put(object, "attributedTo", attributed_to)
	end

	# TODO: Revisit this
	def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

	def prepare_attachments(object) do
	attachments =
	object
	\|> Map.get("attachment", [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} = url \| _] = data["url"]

	%{
	"url" => href,
	"mediaType" => media_type,
	"name" => data["name"],
	"type" => "Document"
	}
	\|> Maps.put_if_present("width", url["width"])
	\|> Maps.put_if_present("height", url["height"])
	\|> Maps.put_if_present("blurhash", data["blurhash"])
	end)

	Map.put(object, "attachment", attachments)
	end

	def strip_internal_fields(object) do
	Map.drop(object, Pleroma.Constants.object_internal_fields())
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags = Enum.filter(tags, fn x -> is_map(x) end)

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

	defp strip_internal_tags(object), do: object

	- def perform(:user_upgrade, user) do
	- # we pass a fake user so that the followers collection is stripped away
	- old_follower_address = User.ap_followers(%User{nickname: user.nickname})
	-
	- from(
	- a in Activity,
	- where: ^old_follower_address in a.recipients,
	- update: [
	- set: [
	- recipients:
	- fragment(
	- "array_replace(?,?,?)",
	- a.recipients,
	- ^old_follower_address,
	- ^user.follower_address
	- )
	- ]
	- ]
	- )
	- \|> Repo.update_all([])
	- end
	-
	- def upgrade_user_from_ap_id(ap_id) do
	- with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
	- {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
	- {:ok, user} <- update_user(user, data) do
	- {:ok, _pid} = Task.start(fn -> ActivityPub.pinned_fetch_task(user) end)
	- TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
	- {:ok, user}
	- else
	- %User{} = user -> {:ok, user}
	- e -> e
	- end
	- end
	-
	- defp update_user(user, data) do
	- user
	- \|> User.remote_user_changeset(data)
	- \|> User.update_and_set_cache()
	- end
	-
	def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
	Map.put(data, "url", url["href"])
	end

	def maybe_fix_user_url(data), do: data

	def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
	end
	diff --git a/lib/pleroma/web/federator.ex b/lib/pleroma/web/federator.ex
	index 318b6cb11..84b77cda1 100644
	--- a/lib/pleroma/web/federator.ex
	+++ b/lib/pleroma/web/federator.ex
	@@ -1,123 +1,112 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	require Logger

	@behaviour Pleroma.Web.Federator.Publishing

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

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

	# Client API

	def incoming_ap_doc(params) do
	ReceiverWorker.enqueue("incoming_ap_doc", %{"params" => params})
	end

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

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

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

	# Job Worker Callbacks

	@spec perform(atom(), module(), any()) :: {:ok, any()} \| {:error, any()}
	def perform(:publish_one, module, params) do
	apply(module, :publish_one, [params])
	end

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

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

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

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

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

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

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

	{:error, {:validate_object, _}} = e ->
	Logger.error("Incoming AP doc validation error: #{inspect(e)}")
	Logger.debug(Jason.encode!(params, pretty: true))
	e

	e ->
	# Just drop those for now
	Logger.debug(fn -> "Unhandled activity\n" <> Jason.encode!(params, pretty: true) end)
	{:error, e}
	end
	end
	-
	- def ap_enabled_actor(id) do
	- user = User.get_cached_by_ap_id(id)
	-
	- if User.ap_enabled?(user) do
	- {:ok, user}
	- else
	- ActivityPub.make_user_from_ap_id(id)
	- end
	- end
	end
	diff --git a/lib/pleroma/workers/transmogrifier_worker.ex b/lib/pleroma/workers/transmogrifier_worker.ex
	deleted file mode 100644
	index 1f3f5385e..000000000
	--- a/lib/pleroma/workers/transmogrifier_worker.ex
	+++ /dev/null
	@@ -1,18 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Workers.TransmogrifierWorker do
	- alias Pleroma.User
	-
	- use Pleroma.Workers.WorkerHelper, queue: "transmogrifier"
	-
	- @impl Oban.Worker
	- def perform(%Job{args: %{"op" => "user_upgrade", "user_id" => user_id}}) do
	- user = User.get_cached_by_id(user_id)
	- Pleroma.Web.ActivityPub.Transmogrifier.perform(:user_upgrade, user)
	- end
	-
	- @impl Oban.Worker
	- def timeout(_job), do: :timer.seconds(5)
	-end
	diff --git a/priv/repo/migrations/20230504173400_remove_user_ap_enabled.exs b/priv/repo/migrations/20230504173400_remove_user_ap_enabled.exs
	new file mode 100644
	index 000000000..0aea41324
	--- /dev/null
	+++ b/priv/repo/migrations/20230504173400_remove_user_ap_enabled.exs
	@@ -0,0 +1,13 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Repo.Migrations.RemoveUserApEnabled do
	+ use Ecto.Migration
	+
	+ def change do
	+ alter table(:users) do
	+ remove(:ap_enabled, :boolean, default: false, null: false)
	+ end
	+ end
	+end
	diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
	index c16312a65..7f60b959a 100644
	--- a/test/pleroma/user_test.exs
	+++ b/test/pleroma/user_test.exs
	@@ -1,2921 +1,2916 @@
	# 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_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(follower, unlocked)
	CommonAPI.follow(follower, locked)

	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(pending_follower, locked)
	CommonAPI.follow(pending_follower, locked)
	CommonAPI.follow(accepted_follower, locked)

	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(pending_follower, locked)

	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(follower, followed)
	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 mutliple 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 mutliple 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 runned on subdomain" do
	setup do: clear_config([Pleroma.Web.WebFinger, :update_nickname_on_user_fetch], true)

	test "for mastodon" do
	Tesla.Mock.mock(fn
	%{url: "https://example.com/.well-known/host-meta"} ->
	%Tesla.Env{
	status: 302,
	headers: [{"location", "https://sub.example.com/.well-known/host-meta"}]
	}

	%{url: "https://sub.example.com/.well-known/host-meta"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/webfinger/masto-host-meta.xml"
	\|> File.read!()
	\|> String.replace("{{domain}}", "sub.example.com")
	}

	%{url: "https://sub.example.com/.well-known/webfinger?resource=acct:a@example.com"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/webfinger/masto-webfinger.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "a")
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{subdomain}}", "sub.example.com"),
	headers: [{"content-type", "application/jrd+json"}]
	}

	%{url: "https://sub.example.com/users/a"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/webfinger/masto-user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "a")
	\|> String.replace("{{domain}}", "sub.example.com"),
	headers: [{"content-type", "application/activity+json"}]
	}

	%{url: "https://sub.example.com/users/a/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/users_mock/masto_featured.json")
	\|> String.replace("{{domain}}", "sub.example.com")
	\|> String.replace("{{nickname}}", "a"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	ap_id = "a@example.com"
	{:ok, fetched_user} = User.get_or_fetch(ap_id)

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

	test "for pleroma" do
	Tesla.Mock.mock(fn
	%{url: "https://example.com/.well-known/host-meta"} ->
	%Tesla.Env{
	status: 302,
	headers: [{"location", "https://sub.example.com/.well-known/host-meta"}]
	}

	%{url: "https://sub.example.com/.well-known/host-meta"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/webfinger/pleroma-host-meta.xml"
	\|> File.read!()
	\|> String.replace("{{domain}}", "sub.example.com")
	}

	%{url: "https://sub.example.com/.well-known/webfinger?resource=acct:a@example.com"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/webfinger/pleroma-webfinger.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "a")
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{subdomain}}", "sub.example.com"),
	headers: [{"content-type", "application/jrd+json"}]
	}

	%{url: "https://sub.example.com/users/a"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/webfinger/pleroma-user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "a")
	\|> String.replace("{{domain}}", "sub.example.com"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	ap_id = "a@example.com"
	{:ok, fetched_user} = User.get_or_fetch(ap_id)

	assert fetched_user.ap_id == "https://sub.example.com/users/a"
	assert fetched_user.nickname == "a@example.com"
	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

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

	test "returns nil for nonexistant local user" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == "not found nonexistant"
	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")

	assert user.inbox

	refute 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

	@tag capture_log: true
	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_adress" 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
	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?(user2, activity)}] ==
	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(user, activity_two.id)
	{:ok, like_two} = CommonAPI.favorite(follower, activity.id)
	{: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,
	- ap_enabled: true,
	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,
	- ap_enabled: 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 fetches a user that's not in the db" do
	assert {:ok, _key} = 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 "is_internal_user?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.is_internal_user?(user)
	end

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

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.is_internal_user?(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",
	- ap_enabled: true
	+ 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",
	- ap_enabled: true
	+ 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",
	- ap_enabled: true
	+ 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 and remote users" do
	local_user =
	insert(:user, nickname: "local_user", ap_id: "https://somehost.com/users/local_user")

	remote_user = insert(:user, nickname: "remote@host.com", local: false)

	assert User.full_nickname(local_user) == "local_user@somehost.com"
	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 "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
	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 ef91066c1..62eb9b5a3 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,2075 +1,2074 @@
	# 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_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.is_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.is_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.is_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.is_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.is_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

	@tag capture_log: true
	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",
	- ap_enabled: true,
	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

	@tag capture_log: true
	test "without valid signature, " <>
	"it only 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

	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 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

	@tag capture_log: true
	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

	@tag capture_log: true
	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

	@tag capture_log: true
	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(another, note.id)

	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
	end

	describe "GET /users/:nickname/outbox" do
	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 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(voter, question, [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
	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 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, _other_user, user, _activity} = CommonAPI.follow(other_user, 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, user, _other_user, _activity} = CommonAPI.follow(user, other_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
	end

	test "pinned collection", %{conn: conn} do
	clear_config([:instance, :max_pinned_statuses], 2)
	user = insert(:user)
	objects = insert_list(2, :note, user: user)

	Enum.reduce(objects, user, fn %{data: %{"id" => object_id}}, user ->
	{:ok, updated} = User.add_pinned_object_id(user, object_id)
	updated
	end)

	%{nickname: nickname, featured_address: featured_address, pinned_objects: pinned_objects} =
	refresh_record(user)

	%{"id" => ^featured_address, "orderedItems" => items, "totalItems" => 2} =
	conn
	\|> get("/users/#{nickname}/collections/featured")
	\|> json_response(200)

	object_ids = Enum.map(items, & &1["id"])

	assert Enum.all?(pinned_objects, fn {obj_id, _} ->
	obj_id in object_ids
	end)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_test.exs b/test/pleroma/web/activity_pub/activity_pub_test.exs
	index a6f8b6152..54fc6ef0a 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_test.exs
	@@ -1,2656 +1,2655 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Mock
	import Pleroma.Factory
	import Tesla.Mock

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

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

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

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

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

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

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

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

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

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

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

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

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

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

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	- assert user.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it returns a user that accepts chat messages" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.accepts_chat_messages
	end

	test "works for guppe actors" do
	user_id = "https://gup.pe/u/bernie2020"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/guppe-actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.name == "Bernie2020 group"
	assert user.actor_type == "Group"
	end

	test "works for bridgy actors" do
	user_id = "https://fed.brid.gy/jk.nipponalba.scot"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/bridgy/actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.actor_type == "Person"

	assert user.avatar == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	}

	assert user.banner == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	}
	end

	test "fetches user featured collection" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	Tesla.Mock.mock_global(fn
	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)
	Process.sleep(50)

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user featured collection without embedded object" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/external_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	Tesla.Mock.mock_global(fn
	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)
	Process.sleep(50)

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user birthday information from misskey" do
	user_id = "https://misskey.io/@mkljczk"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^user_id
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/birthdays/misskey-user.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.birthday == ~D[2001-02-12]
	end
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #TEST"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #Reject"})

	{:ok, status_four} = CommonAPI.post(user, %{status: ". #Any1 #any2"})
	{:ok, status_five} = CommonAPI.post(user, %{status: ". #Any2 #any1"})

	for hashtag_timeline_strategy <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_strategy)

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["TEST", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "Essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "REJECT"]
	})

	# Testing that deduplication (if needed) is done on DB (not Ecto) level; :limit is important
	fetch_five =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["ANY1", "any2"],
	limit: 2
	})

	fetch_six =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["any1", "Any2"],
	tag_all: [],
	tag_reject: []
	})

	# Regression test: passing empty lists as filter options shouldn't affect the results
	assert fetch_five == fetch_six

	[fetch_one, fetch_two, fetch_three, fetch_four, fetch_five] =
	Enum.map([fetch_one, fetch_two, fetch_three, fetch_four, fetch_five], fn statuses ->
	Enum.map(statuses, fn s -> Repo.preload(s, object: :hashtags) end)
	end)

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	assert fetch_five == [status_four, status_five]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity, fetch: false)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity, fetch: false)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{type: ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	test "it reverts create", %{user: user} do
	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:ok, _} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	},
	additional: %{
	"expires_at" => DateTime.utc_now()
	}
	})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	insert(:filter, user: user, phrase: "test", hide: true)

	{:ok, %{id: id1, data: %{"context" => context}}} = CommonAPI.post(user, %{status: "1"})

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	\|> ActivityPub.fetch_activities_for_context(%{user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return activities from deactivated users" do
	_user = insert(:user)
	deactivated = insert(:user)
	active = insert(:user)
	{:ok, activity_one} = CommonAPI.post(deactivated, %{status: "hey!"})
	{:ok, activity_two} = CommonAPI.post(active, %{status: "yay!"})
	{:ok, _updated_user} = User.set_activation(deactivated, false)

	activities = ActivityPub.fetch_activities([], %{})

	refute Enum.member?(activities, activity_one)
	assert Enum.member?(activities, activity_two)
	end

	test "always see your own posts even when they address people you block" do
	user = insert(:user)
	blockee = insert(:user)

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

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

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

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

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

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

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

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

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

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two, fetch: false)

	data = %{
	"actor" => friend.ap_id,
	"object" => object.data["id"],
	"context" => object.data["context"],
	"type" => "Announce",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [blockee.ap_id]
	}

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(user, followed_user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "see your own posts even when they adress actors from blocked domains" do
	user = insert(:user)

	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})

	{:ok, user} = User.block_domain(user, domain)

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

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker, domain_user} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

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

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "returns your own posts regardless of mute" do
	user = insert(:user)
	muted = insert(:user)

	{:ok, muted_post} = CommonAPI.post(muted, %{status: "Im stupid"})

	{:ok, reply} =
	CommonAPI.post(user, %{status: "I'm muting you", in_reply_to_status_id: muted_post.id})

	{:ok, _} = User.mute(user, muted)

	[activity] = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert activity.id == reply.id
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

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

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	insert(:filter, user: user_two, phrase: "cofe", hide: true)
	insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	insert(:filter, user: user_two, phrase: "test", hide: false)

	params = %{
	type: ["Create", "Announce"],
	user: user_two
	}

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

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)

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

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(user, booster)

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

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "strips / from filename", %{test_file: file} do
	file = %Plug.Upload{file \| filename: "../../../../../nested/bad.jpg"}
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	[%{"href" => href}] = object.data["url"]
	assert Regex.match?(~r"/bad.jpg$", href)
	refute Regex.match?(~r"/nested/", href)
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "it sets the default description depending on the configuration", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description])

	clear_config([Pleroma.Upload, :default_description], nil)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == ""

	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"

	clear_config([Pleroma.Upload, :default_description], "unnamed attachment")
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "unnamed attachment"
	end

	test "copies the file to the configured folder", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

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

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

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

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

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{is_locked: true})

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1, user3} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2, user3} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3, user2} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

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

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

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

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "strips status data from Flag, before federating it",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	object_ap_id: object_ap_id,
	content: content
	},
	Utils,
	[:passthrough],
	[] do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	new_data = put_in(activity.data, ["object"], [target_account.ap_id, object_ap_id])

	assert_called(Utils.maybe_federate(%{activity \| data: new_data}))
	end

	test_with_mock "reverts on error",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	maybe_federate: fn _ -> {:error, :reverted} end do
	assert {:error, :reverted} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.aggregate(Object, :count, :id) == 1
	assert Repo.aggregate(Notification, :count, :id) == 0
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "synchronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

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

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

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

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:8080/followers/fuser3",
	following_address: "http://localhost:8080/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_hidden_counters/following" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/followers"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"http://localhost:4001/users/masto_hidden_counters/followers" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/following"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
	following_address: "http://localhost:4001/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(user, a4.id)
	{:ok, _} = CommonAPI.favorite(other_user, a3.id)
	{:ok, _} = CommonAPI.favorite(user, a3.id)
	{:ok, _} = CommonAPI.favorite(other_user, a5.id)
	{:ok, _} = CommonAPI.favorite(user, a5.id)
	{:ok, _} = CommonAPI.favorite(other_user, a4.id)
	{:ok, _} = CommonAPI.favorite(user, a1.id)
	{:ok, _} = CommonAPI.favorite(other_user, a1.id)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

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

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true,
	recipients: recipients
	} = activity

	assert old_user.follower_address in recipients

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end

	test "do not move remote user following relationships" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower_remote = insert(:user, local: false)

	User.follow(follower_remote, old_user)

	assert User.following?(follower_remote, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	assert User.following?(follower_remote, old_user)
	refute User.following?(follower_remote, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

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

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

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

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

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

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u3} = User.follow(u1, u3)
	{:ok, u3, u1} = User.follow(u3, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

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

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

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

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end

	describe "reply filtering" do
	test "`following` still contains announcements by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})

	{:ok, not_followed_to_followed} =
	CommonAPI.post(not_followed, %{
	status: "Also hello",
	in_reply_to_status_id: followed_post.id
	})

	{:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

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

	followed_post_id = followed_post.id
	retoot_id = retoot.id

	assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities

	assert length(activities) == 2
	end

	# This test is skipped because, while this is the desired behavior,
	# there seems to be no good way to achieve it with the method that
	# we currently use for detecting to who a reply is directed.
	# This is a TODO and should be fixed by a later rewrite of the code
	# in question.
	@tag skip: true
	test "`following` still contains self-replies by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	{:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})

	{:ok, _followed_to_not_followed} =
	CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})

	{:ok, _followed_self_reply} =
	CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

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

	assert length(activities) == 2
	end
	end

	test "allow fetching of accounts with an empty string name field" do
	Tesla.Mock.mock(fn
	%{method: :get, url: "https://princess.cat/users/mewmew"} ->
	file = File.read!("test/fixtures/mewmew_no_name.json")
	%Tesla.Env{status: 200, body: file, headers: HttpRequestMock.activitypub_object_headers()}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id("https://princess.cat/users/mewmew")
	assert user.name == " "
	end
	end
	diff --git a/test/pleroma/web/activity_pub/publisher_test.exs b/test/pleroma/web/activity_pub/publisher_test.exs
	index e2db3d575..c5137cbb7 100644
	--- a/test/pleroma/web/activity_pub/publisher_test.exs
	+++ b/test/pleroma/web/activity_pub/publisher_test.exs
	@@ -1,438 +1,433 @@
	# 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.PublisherTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.CommonAPI

	@as_public "https://www.w3.org/ns/activitystreams#Public"

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

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

	describe "gather_webfinger_links/1" do
	test "it returns links" do
	user = insert(:user)

	expected_links = [
	%{"href" => user.ap_id, "rel" => "self", "type" => "application/activity+json"},
	%{
	"href" => user.ap_id,
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]

	assert expected_links == Publisher.gather_webfinger_links(user)
	end
	end

	describe "determine_inbox/2" do
	test "it returns sharedInbox for messages involving as:Public in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"to" => [@as_public], "cc" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving as:Public in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"cc" => [@as_public], "to" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"cc" => [], "to" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"to" => [], "cc" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	user_two = insert(:user)

	activity = %Activity{
	data: %{"to" => [user_two.ap_id], "cc" => [user.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns inbox for messages involving single recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	activity = %Activity{
	data: %{"to" => [user.ap_id], "cc" => []}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/personal-inbox"
	end
	end

	describe "publish_one/1" do
	test "publish to url with with different ports" do
	inbox80 = "http://42.site/users/nick1/inbox"
	inbox42 = "http://42.site:42/users/nick1/inbox"

	mock(fn
	%{method: :post, url: "http://42.site:42/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 42"}}

	%{method: :post, url: "http://42.site/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 80"}}
	end)

	actor = insert(:user)

	assert {:ok, %{body: "port 42"}} =
	Publisher.publish_one(%{
	inbox: inbox42,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: true
	})

	assert {:ok, %{body: "port 80"}} =
	Publisher.publish_one(%{
	inbox: inbox80,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: true
	})
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: nil
	})

	refute called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://404.site/users/nick1/inbox"

	assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert capture_log(fn ->
	assert {:error, _} =
	Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
	end) =~ "connrefused"

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	refute called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert capture_log(fn ->
	assert {:error, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})
	end) =~ "connrefused"

	refute called(Instances.set_unreachable(inbox))
	end
	end

	describe "publish/2" do
	test_with_mock "doesn't publish a non-public activity to quarantined instances.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	Config.put([:instance, :quarantined_instances], [{"domain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	- inbox: "https://domain.com/users/nick1/inbox",
	- ap_enabled: true
	+ inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert not called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)
	end

	test_with_mock "Publishes a non-public activity to non-quarantined instances.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	Config.put([:instance, :quarantined_instances], [{"somedomain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	- inbox: "https://domain.com/users/nick1/inbox",
	- ap_enabled: true
	+ inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)
	end

	test_with_mock "publishes an activity with BCC to all relevant peers.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	follower =
	insert(:user, %{
	local: false,
	- inbox: "https://domain.com/users/nick1/inbox",
	- ap_enabled: true
	+ inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)
	user = insert(:user)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)

	note_activity =
	insert(:note_activity,
	recipients: [follower.ap_id],
	data_attrs: %{"bcc" => [user.ap_id]}
	)

	res = Publisher.publish(actor, note_activity)
	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)
	end

	test_with_mock "publishes a delete activity to peers who signed fetch requests to the create acitvity/object.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	fetcher =
	insert(:user,
	local: false,
	- inbox: "https://domain.com/users/nick1/inbox",
	- ap_enabled: true
	+ inbox: "https://domain.com/users/nick1/inbox"
	)

	another_fetcher =
	insert(:user,
	local: false,
	- inbox: "https://domain2.com/users/nick1/inbox",
	- ap_enabled: true
	+ inbox: "https://domain2.com/users/nick1/inbox"
	)

	actor = insert(:user)

	note_activity = insert(:note_activity, user: actor)
	object = Object.normalize(note_activity, fetch: false)

	activity_path = String.trim_leading(note_activity.data["id"], Pleroma.Web.Endpoint.url())
	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, fetcher)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, another_fetcher)
	\|> get(activity_path)
	\|> json_response(200)

	{:ok, delete} = CommonAPI.delete(note_activity.id, actor)

	res = Publisher.publish(actor, delete)
	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: delete.data["id"]
	})
	)

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain2.com/users/nick1/inbox",
	actor_id: actor.id,
	id: delete.data["id"]
	})
	)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index f76606479..3e0c8dc65 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,656 +1,592 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	- alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

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

	describe "handle_incoming" do
	test "it works for incoming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})
	object = Object.normalize(activity, fetch: false)

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

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, activity.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

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

	assert activity.data["object"] == [user.ap_id, note_obj]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it accepts Move activities" do
	old_user = insert(:user)
	new_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Move",
	"actor" => old_user.ap_id,
	"object" => old_user.ap_id,
	"target" => new_user.ap_id
	}

	assert :error = Transmogrifier.handle_incoming(message)

	{:ok, _new_user} = User.update_and_set_cache(new_user, %{also_known_as: [old_user.ap_id]})

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(message)
	assert activity.actor == old_user.ap_id
	assert activity.data["actor"] == old_user.ap_id
	assert activity.data["object"] == old_user.ap_id
	assert activity.data["target"] == new_user.ap_id
	assert activity.data["type"] == "Move"
	end

	test "it fixes both the Create and object contexts in a reply" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")
	insert(:user, ap_id: "https://p.helene.moe/users/helene")

	create_activity =
	"test/fixtures/create-pleroma-reply-to-misskey-thread.json"
	\|> File.read!()
	\|> Jason.decode!()

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

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

	assert activity.data["context"] == object.data["context"]
	end

	test "it drops link tags" do
	insert(:user, ap_id: "https://example.org/users/alice")

	message = File.read!("test/fixtures/fep-e232.json") \|> Jason.decode!()

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

	object = Object.normalize(activity)
	assert length(object.data["tag"]) == 1

	tag = object.data["tag"] \|> List.first()
	assert tag["type"] == "Mention"
	end
	end

	describe "prepare outgoing" do
	test "it inlines private announced objects" do
	user = insert(:user)

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

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)

	{:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)

	assert modified["object"]["content"] == "hey"
	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})

	with_mock Pleroma.Notification,
	get_notified_from_activity: fn _, _ -> [] end do
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	refute called(Pleroma.Notification.get_notified_from_activity(:_, :_))
	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] == Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

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

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "#2hu :firefox:",
	generator: %{type: "Application", name: "TestClient", url: "https://pleroma.social"}
	})

	# Ensure injected application data made it into the activity
	# as we don't have a Token to derive it from, otherwise it will
	# be nil and the test will pass
	assert %{
	type: "Application",
	name: "TestClient",
	url: "https://pleroma.social"
	} == activity.object.data["generator"]

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["generator"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["likes"])
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert is_nil(modified["bcc"])
	end

	test "it can handle Listen activities" do
	listen_activity = insert(:listen)

	{:ok, modified} = Transmogrifier.prepare_outgoing(listen_activity.data)

	assert modified["type"] == "Listen"

	user = insert(:user)

	{:ok, activity} = CommonAPI.listen(user, %{"title" => "lain radio episode 1"})

	{:ok, _modified} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "custom emoji urls are URI encoded" do
	# :dinosaur: filename has a space -> dino walking.gif
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(prepared["object"]["tag"]) == 1

	url = prepared["object"]["tag"] \|> List.first() \|> Map.get("icon") \|> Map.get("url")

	assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	end

	test "Updates of Notes are handled" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})
	{:ok, update} = CommonAPI.update(user, activity, %{status: "mew mew :blank:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(update.data)

	assert %{
	"content" => "mew mew :blank:",
	"tag" => [%{"name" => ":blank:", "type" => "Emoji"}],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"content" => "everybody do the dinosaur :dinosaur:",
	"tag" => [%{"name" => ":dinosaur:", "type" => "Emoji"}]
	}
	]
	}
	} = prepared["object"]
	end
	end

	- describe "user upgrade" do
	- test "it upgrades a user to activitypub" do
	- user =
	- insert(:user, %{
	- nickname: "rye@niu.moe",
	- local: false,
	- ap_id: "https://niu.moe/users/rye",
	- follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	- })
	-
	- user_two = insert(:user)
	- Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept)
	-
	- {:ok, activity} = CommonAPI.post(user, %{status: "test"})
	- {:ok, unrelated_activity} = CommonAPI.post(user_two, %{status: "test"})
	- assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
	-
	- user = User.get_cached_by_id(user.id)
	- assert user.note_count == 1
	-
	- {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	- ObanHelpers.perform_all()
	-
	- assert user.ap_enabled
	- assert user.note_count == 1
	- assert user.follower_address == "https://niu.moe/users/rye/followers"
	- assert user.following_address == "https://niu.moe/users/rye/following"
	-
	- user = User.get_cached_by_id(user.id)
	- assert user.note_count == 1
	-
	- activity = Activity.get_by_id(activity.id)
	- assert user.follower_address in activity.recipients
	-
	- assert %{
	- "url" => [
	- %{
	- "href" =>
	- "https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	- }
	- ]
	- } = user.avatar
	-
	- assert %{
	- "url" => [
	- %{
	- "href" =>
	- "https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	- }
	- ]
	- } = user.banner
	-
	- refute "..." in activity.recipients
	-
	- unrelated_activity = Activity.get_by_id(unrelated_activity.id)
	- refute user.follower_address in unrelated_activity.recipients
	-
	- user_two = User.get_cached_by_id(user_two.id)
	- assert User.following?(user_two, user)
	- refute "..." in User.following(user_two)
	- end
	- end
	-
	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end

	describe "fix_summary/1" do
	test "returns fixed object" do
	assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
	assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
	assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
	end
	end

	describe "fix_url/1" do
	test "fixes data for object when url is map" do
	object = %{
	"url" => %{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	}

	assert Transmogrifier.fix_url(object) == %{
	"url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	end

	test "returns non-modified object" do
	assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
	end
	end

	describe "get_obj_helper/2" do
	test "returns nil when cannot normalize object" do
	assert capture_log(fn ->
	refute Transmogrifier.get_obj_helper("test-obj-id")
	end) =~ "Unsupported URI scheme"
	end

	@tag capture_log: true
	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)
	end
	end

	describe "fix_attachments/1" do
	test "puts dimensions into attachment url field" do
	object = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960,
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	expected = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpeg",
	"href" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960
	}
	],
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	assert Transmogrifier.fix_attachments(object) == expected
	end
	end

	describe "prepare_object/1" do
	test "it processes history" do
	original = %{
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)

	history_item = Enum.at(processed["formerRepresentations"]["orderedItems"], 0)

	refute Map.has_key?(history_item, "generator")

	assert [%{"name" => ":blobcat:"}] = history_item["tag"]
	end

	test "it works when there is no or bad history" do
	original = %{
	"formerRepresentations" => %{
	"items" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)
	assert processed["formerRepresentations"] == original["formerRepresentations"]
	end
	end
	end
	diff --git a/test/pleroma/web/common_api_test.exs b/test/pleroma/web/common_api_test.exs
	index 968d826a2..3112d831b 100644
	--- a/test/pleroma/web/common_api_test.exs
	+++ b/test/pleroma/web/common_api_test.exs
	@@ -1,1738 +1,1738 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.PollWorker

	import Pleroma.Factory
	import Mock
	import Ecto.Query, only: [from: 2]

	require Pleroma.Constants

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

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	describe "posting polls" do
	test "it posts a poll" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "who is the best",
	poll: %{expires_in: 600, options: ["reimu", "marisa"]}
	})

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

	assert object.data["type"] == "Question"
	assert object.data["oneOf"] \|> length() == 2

	assert_enqueued(
	worker: PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: NaiveDateTime.from_iso8601!(object.data["closed"])
	)
	end
	end

	describe "blocking" do
	setup do
	blocker = insert(:user)
	blocked = insert(:user, local: false)
	CommonAPI.follow(blocker, blocked)
	CommonAPI.follow(blocked, blocker)
	CommonAPI.accept_follow_request(blocker, blocked)
	CommonAPI.accept_follow_request(blocked, blocked)
	%{blocker: blocker, blocked: blocked}
	end

	test "it blocks and federates", %{blocker: blocker, blocked: blocked} do
	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert User.get_follow_state(blocker, blocked) == :follow_accept
	refute is_nil(Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked))

	assert {:ok, block} = CommonAPI.block(blocker, blocked)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute User.get_follow_state(blocker, blocked)

	assert %{data: %{"state" => "reject"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked)

	assert called(Pleroma.Web.Federator.publish(block))
	end
	end

	test "it blocks and does not federate if outgoing blocks are disabled", %{
	blocker: blocker,
	blocked: blocked
	} do
	clear_config([:instance, :federating], true)
	clear_config([:activitypub, :outgoing_blocks], false)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, block} = CommonAPI.block(blocker, blocked)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute called(Pleroma.Web.Federator.publish(block))
	end
	end
	end

	describe "posting chat messages" do
	setup do: clear_config([:instance, :chat_limit])

	test "it posts a self-chat" do
	author = insert(:user)
	recipient = author

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"remember to buy milk when milk truk arive"
	)

	assert activity.data["type"] == "Create"
	end

	test "it posts a chat message without content but with an attachment" do
	author = insert(:user)
	recipient = insert(:user)

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

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

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ ->
	nil
	end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	nil,
	media_id: upload.id
	)

	notification =
	Notification.for_user_and_activity(recipient, activity)
	\|> Repo.preload(:activity)

	assert called(Pleroma.Web.Push.send(notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	assert activity
	end
	end

	test "it adds html newlines" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"uguu\nuguuu"
	)

	assert other_user.ap_id not in activity.recipients

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

	assert object.data["content"] == "uguu<br/>uguuu"
	end

	test "it linkifies" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"https://example.org is the site of @#{other_user.nickname} #2hu"
	)

	assert other_user.ap_id not in activity.recipients

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

	assert object.data["content"] ==
	"<a href=\"https://example.org\" rel=\"ugc\">https://example.org</a> is the site of <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{other_user.id}\" href=\"#{other_user.ap_id}\" rel=\"ugc\">@<span>#{other_user.nickname}</span></a></span> <a class=\"hashtag\" data-tag=\"2hu\" href=\"http://localhost:4001/tag/2hu\">#2hu</a>"
	end

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

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"a test message <script>alert('uuu')</script> :firefox:"
	)

	assert activity.data["type"] == "Create"
	assert activity.local
	object = Object.normalize(activity, fetch: false)

	assert object.data["type"] == "ChatMessage"
	assert object.data["to"] == [recipient.ap_id]

	assert object.data["content"] ==
	"a test message <script>alert('uuu')</script> :firefox:"

	assert object.data["emoji"] == %{
	"firefox" => "http://localhost:4001/emoji/Firefox.gif"
	}

	assert Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)

	assert :ok == Pleroma.Web.Federator.perform(:publish, activity)
	end

	test "it reject messages over the local limit" do
	clear_config([:instance, :chat_limit], 2)

	author = insert(:user)
	recipient = insert(:user)

	{:error, message} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"123"
	)

	assert message == :content_too_long
	end

	test "it reject messages via MRF" do
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	author = insert(:user)
	recipient = insert(:user)

	assert {:reject, "[KeywordPolicy] Matches with rejected keyword"} ==
	CommonAPI.post_chat_message(author, recipient, "GNO/Linux")
	end
	end

	describe "unblocking" do
	test "it works even without an existing block activity" do
	blocked = insert(:user)
	blocker = insert(:user)
	User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	assert {:ok, :no_activity} == CommonAPI.unblock(blocker, blocked)
	refute User.blocks?(blocker, blocked)
	end
	end

	describe "deletion" do
	test "it works with pruned objects" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	Object.normalize(post, fetch: false)
	\|> Object.prune()

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows users to delete their posts" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it does not allow a user to delete posts from another user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
	assert Activity.get_by_id(post.id)
	end

	test "it allows privileged users to delete other user's posts" do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "it doesn't allow unprivileged mods or admins to delete other user's posts" do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true, is_admin: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, moderator)
	assert Activity.get_by_id(post.id)
	end

	test "privileged users deleting non-local posts won't federate the delete" do
	clear_config([:instance, :admin_privileges], [:messages_delete])
	# This is the user of the ingested activity
	_user =
	insert(:user,
	local: false,
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: NaiveDateTime.utc_now()
	)

	admin = insert(:user, is_admin: true)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	{:ok, post} = Transmogrifier.handle_incoming(data)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, admin)
	assert delete.local
	refute called(Pleroma.Web.Federator.publish(:_))
	end

	refute Activity.get_by_id(post.id)
	end
	end

	test "favoriting race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.favorite(user, activity.id)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.favorite(user, activity.id)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 20
	end

	test "repeating race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.repeat(activity.id, user)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.repeat(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 20
	end

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})

	assert Visibility.is_direct?(convo_reply)

	assert activity.data["context"] == convo_reply.data["context"]
	end

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

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

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "I don't really like @#{tridi.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

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

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	visibility: "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})

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

	assert Object.tags(object) == ["2hu"]
	end

	test "zwnj is treated as word character" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#ساٴين‌س"})

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

	assert Object.tags(object) == ["ساٴين‌س"]
	end

	test "allows lang attribute" do
	user = insert(:user)
	text = ~s{<span lang="en">something</span><p lang="diaetuitech_rpyhpgc">random</p>}

	{:ok, activity} = CommonAPI.post(user, %{status: text, content_type: "text/html"})

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

	assert object.data["content"] == text
	end

	test "double dot in link is allowed" do
	user = insert(:user)
	text = "https://example.to/something..mp3"
	{:ok, activity} = CommonAPI.post(user, %{status: text})

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

	assert object.data["content"] == "<a href=\"#{text}\" rel=\"ugc\">#{text}</a>"
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})

	assert Object.normalize(activity, fetch: false).data["emoji"]["firefox"]
	end

	describe "posting" do
	test "it adds an emoji on an external site" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey :external_emoji:"})

	assert %{"external_emoji" => url} = Object.normalize(activity).data["emoji"]
	assert url == "https://example.com/emoji.png"

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

	assert %{"blank" => url} = Object.normalize(activity).data["emoji"]
	assert url == "#{Pleroma.Web.Endpoint.url()}/emoji/blank.png"
	end

	test "it copies emoji from the subject of the parent post" do
	%Object{} =
	object =
	Object.normalize("https://patch.cx/objects/a399c28e-c821-4820-bc3e-4afeb044c16f",
	fetch: true
	)

	activity = Activity.get_create_by_object_ap_id(object.data["id"])
	user = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(user, %{
	in_reply_to_id: activity.id,
	status: ":joker_disapprove:",
	spoiler_text: ":joker_smile:"
	})

	assert Object.normalize(reply_activity).data["emoji"]["joker_smile"]
	refute Object.normalize(reply_activity).data["emoji"]["joker_disapprove"]
	end

	test "deactivated users can't post" do
	user = insert(:user, is_active: false)
	assert {:error, _} = CommonAPI.post(user, %{status: "ye"})
	end

	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	to: [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/html"
	})

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

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	assert object.data["source"]["content"] == post
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

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

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

	assert object.data["content"] == "<p><b>2hu</b></p>"
	assert object.data["source"]["content"] == post
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: visibility,
	in_reply_to_status_id: activity.id
	})
	end)
	end

	test "replying with a direct message will NOT auto-add the author of the reply to the recipient list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "I'm stupid"})

	{:ok, open_answer} =
	CommonAPI.post(other_user, %{status: "No ur smart", in_reply_to_status_id: post.id})

	# The OP is implicitly added
	assert user.ap_id in open_answer.recipients

	{:ok, secret_answer} =
	CommonAPI.post(other_user, %{
	status: "lol, that guy really is stupid, right, @#{third_user.nickname}?",
	in_reply_to_status_id: post.id,
	visibility: "direct"
	})

	assert third_user.ap_id in secret_answer.recipients

	# The OP is not added
	refute user.ap_id in secret_answer.recipients
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	assert activity.data["bcc"] == [list.ap_id]
	assert activity.recipients == [list.ap_id, user.ap_id]
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{status: ""})
	end

	test "it validates character limits are correctly enforced" do
	clear_config([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{status: "foobar"})

	assert {:ok, _activity} = CommonAPI.post(user, %{status: "12345"})
	end

	test "it validates media attachment limits are correctly enforced" do
	clear_config([:instance, :max_media_attachments], 4)

	user = insert(:user)

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

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

	assert {:error, "Too many attachments"} =
	CommonAPI.post(user, %{
	status: "",
	media_ids: List.duplicate(upload.id, 5)
	})

	assert {:ok, _activity} =
	CommonAPI.post(user, %{
	status: "",
	media_ids: [upload.id]
	})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)

	assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at: expires_at
	)
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

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

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	assert unreaction.local

	# On federation, it contains the undone (and deleted) object
	unreaction_with_object = %{
	unreaction
	\| data: Map.put(unreaction.data, "object", reaction.data)
	}

	assert called(Pleroma.Web.Federator.publish(unreaction_with_object))
	end
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, user)
	assert Visibility.is_public?(announce_activity)
	end

	test "can't repeat a repeat" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, other_user)

	refute match?({:ok, %Activity{}}, CommonAPI.repeat(announce.id, user))
	end

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} =
	CommonAPI.repeat(activity.id, user, %{visibility: "private"})

	assert Visibility.is_private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)
	end

	test "author can repeat own private statuses" do
	author = insert(:user)
	follower = insert(:user)
	CommonAPI.follow(follower, author)

	{:ok, activity} = CommonAPI.post(author, %{status: "cofe", visibility: "private"})

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, author)

	assert Visibility.is_private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)

	assert Visibility.visible_for_user?(activity, follower)
	assert {:error, :not_found} = CommonAPI.repeat(activity.id, follower)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post_activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
	assert data["type"] == "Like"
	assert data["actor"] == user.ap_id
	assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, user)
	{:ok, ^announce} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
	assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
	end
	end

	describe "pinned statuses" do
	setup do
	clear_config([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "activity not found error", %{user: user} do
	assert {:error, :not_found} = CommonAPI.pin("id", user)
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)
	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How is fediverse today?",
	poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)

	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, :ownership_error} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity_two.id, user)
	end

	test "only public can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "private status", visibility: "private"})
	{:error, :visibility_error} = CommonAPI.pin(activity.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	id = activity.id

	assert match?({:ok, %{id: ^id}}, CommonAPI.unpin(activity.id, user))

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

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

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "ephemeral activity won't be deleted if was pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "Hello!", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)
	refute Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

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

	# recreates expiration job on unpin
	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)
	end

	test "ephemeral activity deletion job won't be deleted on pinning error", %{
	user: user,
	activity: activity
	} do
	clear_config([:instance, :max_pinned_statuses], 1)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)

	{:ok, activity2} = CommonAPI.post(user, %{status: "another status", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)

	user = refresh_record(user)
	{:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity2.id, user)

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "marks notifications as read after mute" do
	author = insert(:user)
	activity = insert(:note_activity, user: author)

	friend1 = insert(:user)
	friend2 = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(
	friend2,
	%{
	status: "@#{author.nickname} @#{friend1.nickname} test reply",
	in_reply_to_status_id: activity.id
	}
	)

	{:ok, favorite_activity} = CommonAPI.favorite(friend2, activity.id)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, friend1)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	unread_notifications =
	Repo.all(from(n in Notification, where: n.seen == false, where: n.user_id == ^author.id))

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)

	{:ok, _} = CommonAPI.add_mute(author, activity)
	assert CommonAPI.thread_muted?(author, activity)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	read_notifications =
	Repo.all(from(n in Notification, where: n.seen == true, where: n.user_id == ^author.id))

	assert Enum.any?(read_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "add expiring mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity, %{expires_in: 60})
	assert CommonAPI.thread_muted?(user, activity)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_conversation", "user_id" => user.id, "activity_id" => activity.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute by ids", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user.id, activity.id)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
	activity = Activity.normalize(activity)

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	reported_object_ap_id = activity.object.data["id"]
	comment = "foobar"

	report_data = %{
	account_id: target_user.id,
	comment: comment,
	status_ids: [activity.id]
	}

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

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)
	object = Object.normalize(activity)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, object_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert object_id == object.data["id"]
	end

	test "updates report state, don't strip when report_strip_status is false" do
	clear_config([:instance, :report_strip_status], false)

	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id, data: report_data}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, reported_activity] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert is_map(reported_activity)

	assert reported_activity["content"] ==
	report_data["object"] \|> Enum.at(1) \|> Map.get("content")
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel very offended!",
	status_ids: [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "follow/2" do
	test "directly follows a non-locked local user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)

	assert User.following?(follower, followed)
	end
	end

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(follower, followed)

	refute User.subscribed_to?(follower, followed)
	end

	test "also unpins a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
	{:ok, _endorsement} = User.endorse(follower, followed)

	assert User.endorses?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(follower, followed)

	refute User.endorses?(follower, followed)
	end

	test "cancels a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	- followed = insert(:user, is_locked: true, local: false, ap_enabled: true)
	+ followed = insert(:user, is_locked: true, local: false)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

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

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

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

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "doesn't create a following relationship if the corresponding follow request doesn't exist" do
	user = insert(:user, is_locked: true)
	not_follower = insert(:user)
	CommonAPI.accept_follow_request(not_follower, user)

	assert Pleroma.FollowingRelationship.following?(not_follower, user) == false
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

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

	{:ok, _, object} = CommonAPI.vote(other_user, object, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(other_user, object, [1])
	end
	end

	describe "listen/2" do
	test "returns a valid activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000
	})

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

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "public"
	end

	test "respects visibility=private" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000,
	visibility: "private"
	})

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

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end

	describe "get_user/1" do
	test "gets user by ap_id" do
	user = insert(:user)
	assert CommonAPI.get_user(user.ap_id) == user
	end

	test "gets user by guessed nickname" do
	user = insert(:user, ap_id: "", nickname: "mario@mushroom.kingdom")
	assert CommonAPI.get_user("https://mushroom.kingdom/users/mario") == user
	end

	test "fallback" do
	assert %User{
	name: "",
	ap_id: "",
	nickname: "erroruser@example.com"
	} = CommonAPI.get_user("")
	end
	end

	describe "with `local` visibility" do
	setup do: clear_config([:instance, :federating], true)

	test "post" do
	user = insert(:user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	assert Visibility.is_local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "delete" do
	user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"deleted_activity_id" => ^activity_id}} = activity} =
	CommonAPI.delete(activity_id, user)

	assert Visibility.is_local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "repeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Announce"}} = activity} =
	CommonAPI.repeat(activity_id, user)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unrepeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	assert {:ok, _} = CommonAPI.repeat(activity_id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unrepeat(activity_id, user)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "favorite" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Like"}} = activity} =
	CommonAPI.favorite(user, activity.id)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unfavorite" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, activity} = CommonAPI.unfavorite(activity.id, user)
	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "react_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "EmojiReact"}} = activity} =
	CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unreact_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, _reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end

	describe "update/3" do
	test "updates a post" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1"})

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end

	test "does not change visibility" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1", visibility: "private"})

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Visibility.get_visibility(updated_object) == "private"
	assert Visibility.get_visibility(updated) == "private"
	end

	test "updates a post with emoji" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2 :#{emoji2}:"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated_object.data["emoji"]
	end

	test "updates a post with emoji and federate properly" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _p -> nil end do
	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2 :#{emoji2}:"})

	assert updated.data["object"]["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated.data["object"]["emoji"]

	assert called(Pleroma.Web.Federator.publish(updated))
	end
	end

	test "editing a post that copied a remote title with remote emoji should keep that emoji" do
	remote_emoji_uri = "https://remote.org/emoji.png"

	note =
	insert(
	:note,
	data: %{
	"summary" => ":remoteemoji:",
	"emoji" => %{
	"remoteemoji" => remote_emoji_uri
	},
	"tag" => [
	%{
	"type" => "Emoji",
	"name" => "remoteemoji",
	"icon" => %{"url" => remote_emoji_uri}
	}
	]
	}
	)

	note_activity = insert(:note_activity, note: note)

	user = insert(:user)

	{:ok, reply} =
	CommonAPI.post(user, %{
	status: "reply",
	spoiler_text: ":remoteemoji:",
	in_reply_to_id: note_activity.id
	})

	assert reply.object.data["emoji"]["remoteemoji"] == remote_emoji_uri

	{:ok, edit} =
	CommonAPI.update(user, reply, %{status: "reply mew mew", spoiler_text: ":remoteemoji:"})

	edited_note = Pleroma.Object.normalize(edit)

	assert edited_note.data["emoji"]["remoteemoji"] == remote_emoji_uri
	end

	test "respects MRF" do
	user = insert(:user)

	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
	clear_config([:mrf_keyword, :replace], [{"updated", "mewmew"}])

	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "updated 1"})
	assert Object.normalize(activity).data["summary"] == "mewmew 1"

	{:ok, updated} = CommonAPI.update(user, activity, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "mewmew 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end
	end
	end
	diff --git a/test/pleroma/web/federator_test.exs b/test/pleroma/web/federator_test.exs
	index 1ffe6aae1..6826e6c2f 100644
	--- a/test/pleroma/web/federator_test.exs
	+++ b/test/pleroma/web/federator_test.exs
	@@ -1,175 +1,173 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.FederatorTest do
	alias Pleroma.Instances
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.PublisherWorker

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

	import Pleroma.Factory
	import Mock

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

	:ok
	end

	setup_all do: clear_config([:instance, :federating], true)
	setup do: clear_config([:instance, :allow_relay])
	setup do: clear_config([:mrf, :policies])
	setup do: clear_config([:mrf_keyword])

	describe "Publish an activity" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI"})

	relay_mock = {
	Pleroma.Web.ActivityPub.Relay,
	[],
	[publish: fn _activity -> send(self(), :relay_publish) end]
	}

	%{activity: activity, relay_mock: relay_mock}
	end

	test "with relays active, it publishes to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	with_mocks([relay_mock]) do
	Federator.publish(activity)
	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))
	end

	assert_received :relay_publish
	end

	test "with relays deactivated, it does not publish to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	clear_config([:instance, :allow_relay], false)

	with_mocks([relay_mock]) do
	Federator.publish(activity)
	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))
	end

	refute_received :relay_publish
	end
	end

	describe "Targets reachability filtering in `publish`" do
	test "it federates only to reachable instances via AP" do
	user = insert(:user)

	{inbox1, inbox2} =
	{"https://domain.com/users/nick1/inbox", "https://domain2.com/users/nick2/inbox"}

	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	- inbox: inbox1,
	- ap_enabled: true
	+ inbox: inbox1
	})

	insert(:user, %{
	local: false,
	nickname: "nick2@domain2.com",
	ap_id: "https://domain2.com/users/nick2",
	- inbox: inbox2,
	- ap_enabled: true
	+ inbox: inbox2
	})

	dt = NaiveDateTime.utc_now()
	Instances.set_unreachable(inbox1, dt)

	Instances.set_consistently_unreachable(URI.parse(inbox2).host)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "HI @nick1@domain.com, @nick2@domain2.com!"})

	expected_dt = NaiveDateTime.to_iso8601(dt)

	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))

	assert ObanHelpers.member?(
	%{
	"op" => "publish_one",
	"params" => %{"inbox" => inbox1, "unreachable_since" => expected_dt}
	},
	all_enqueued(worker: PublisherWorker)
	)
	end
	end

	describe "Receive an activity" do
	test "successfully processes incoming AP docs with correct origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:ok, _activity} = ObanHelpers.perform(job)

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:cancel, :already_present} = ObanHelpers.perform(job)
	end

	test "rejects incoming AP docs with incorrect origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://niu.moe/users/rye",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:cancel, :origin_containment_failed} = ObanHelpers.perform(job)
	end

	test "it does not crash if MRF rejects the post" do
	clear_config([:mrf_keyword, :reject], ["lain"])

	clear_config(
	[:mrf, :policies],
	Pleroma.Web.ActivityPub.MRF.KeywordPolicy
	)

	params =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:cancel, _} = ObanHelpers.perform(job)
	end
	end
	end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index 09f02458c..d94544717 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,666 +1,665 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Factory do
	use ExMachina.Ecto, repo: Pleroma.Repo

	require Pleroma.Constants

	alias Pleroma.Object
	alias Pleroma.User

	@rsa_keys [
	"test/fixtures/rsa_keys/key_1.pem",
	"test/fixtures/rsa_keys/key_2.pem",
	"test/fixtures/rsa_keys/key_3.pem",
	"test/fixtures/rsa_keys/key_4.pem",
	"test/fixtures/rsa_keys/key_5.pem"
	]
	\|> Enum.map(&File.read!/1)

	def participation_factory do
	conversation = insert(:conversation)
	user = insert(:user)

	%Pleroma.Conversation.Participation{
	conversation: conversation,
	user: user,
	read: false
	}
	end

	def conversation_factory do
	%Pleroma.Conversation{
	ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
	}
	end

	def user_factory(attrs \\ %{}) do
	pem = Enum.random(@rsa_keys)

	user = %User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	is_discoverable: true,
	last_digest_emailed_at: NaiveDateTime.utc_now(),
	last_refreshed_at: NaiveDateTime.utc_now(),
	notification_settings: %Pleroma.User.NotificationSetting{},
	multi_factor_authentication_settings: %Pleroma.MFA.Settings{},
	- ap_enabled: true,
	keys: pem
	}

	urls =
	if attrs[:local] == false do
	base_domain = attrs[:domain] \|\| Enum.random(["domain1.com", "domain2.com", "domain3.com"])

	ap_id = "https://#{base_domain}/users/#{user.nickname}"

	%{
	ap_id: ap_id,
	follower_address: ap_id <> "/followers",
	following_address: ap_id <> "/following",
	featured_address: ap_id <> "/collections/featured"
	}
	else
	%{
	ap_id: User.ap_id(user),
	follower_address: User.ap_followers(user),
	following_address: User.ap_following(user),
	featured_address: User.ap_featured_collection(user)
	}
	end

	attrs = Map.delete(attrs, :domain)

	user
	\|> Map.put(:raw_bio, user.bio)
	\|> Map.merge(urls)
	\|> merge_attributes(attrs)
	end

	def user_relationship_factory(attrs \\ %{}) do
	source = attrs[:source] \|\| insert(:user)
	target = attrs[:target] \|\| insert(:user)
	relationship_type = attrs[:relationship_type] \|\| :block

	%Pleroma.UserRelationship{
	source_id: source.id,
	target_id: target.id,
	relationship_type: relationship_type
	}
	end

	def note_factory(attrs \\ %{}) do
	text = sequence(:text, &"This is :moominmamma: note #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Note",
	"content" => text,
	"source" => text,
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"likes" => [],
	"like_count" => 0,
	"context" => "2hu",
	"summary" => "2hu",
	"tag" => ["2hu"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def attachment_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)

	data =
	attachment_data(user.ap_id, nil)
	\|> Map.put("id", Pleroma.Web.ActivityPub.Utils.generate_object_id())

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def attachment_note_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	{length, attrs} = Map.pop(attrs, :length, 1)

	data = %{
	"attachment" =>
	Stream.repeatedly(fn -> attachment_data(user.ap_id, attrs[:href]) end)
	\|> Enum.take(length)
	}

	build(:note, Map.put(attrs, :data, data))
	end

	defp attachment_data(ap_id, href) do
	href = href \|\| sequence(:href, &"#{Pleroma.Web.Endpoint.url()}/media/#{&1}.jpg")

	%{
	"url" => [
	%{
	"href" => href,
	"type" => "Link",
	"mediaType" => "image/jpeg"
	}
	],
	"name" => "some name",
	"type" => "Document",
	"actor" => ap_id,
	"mediaType" => "image/jpeg"
	}
	end

	def followers_only_note_factory(attrs \\ %{}) do
	%Pleroma.Object{data: data} = note_factory(attrs)
	%Pleroma.Object{data: Map.merge(data, %{"to" => [data["actor"] <> "/followers"]})}
	end

	def audio_factory(attrs \\ %{}) do
	text = sequence(:text, &"lain radio episode #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Audio",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"artist" => "lain",
	"title" => text,
	"album" => "lain radio",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"actor" => user.ap_id,
	"length" => 180_000
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def listen_factory do
	audio = insert(:audio)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Listen",
	"actor" => audio.data["actor"],
	"to" => audio.data["to"],
	"object" => audio.data,
	"published" => audio.data["published"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def direct_note_factory do
	user2 = insert(:user)

	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
	end

	def article_factory do
	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"type" => "Article"})}
	end

	def tombstone_factory do
	data = %{
	"type" => "Tombstone",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"formerType" => "Note",
	"deleted" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Object{
	data: data
	}
	end

	def question_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"type" => "Question",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"attachment" => [],
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address],
	"context" => Pleroma.Web.ActivityPub.Utils.generate_context_id(),
	"closed" => DateTime.utc_now() \|> DateTime.add(86_400) \|> DateTime.to_iso8601(),
	"oneOf" => [
	%{
	"type" => "Note",
	"name" => "chocolate",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "vanilla",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	}
	]
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => dm.data["actor"],
	"to" => dm.data["to"],
	"object" => dm.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => dm.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def add_activity_factory(attrs \\ %{}) do
	featured_collection_activity(attrs, "Add")
	end

	def remove_activity_factor(attrs \\ %{}) do
	featured_collection_activity(attrs, "Remove")
	end

	defp featured_collection_activity(attrs, type) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data_attrs =
	attrs
	\|> Map.get(:data_attrs, %{})
	\|> Map.put(:type, type)

	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"target" => user.featured_address,
	"object" => note.data["object"],
	"actor" => note.data["actor"],
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def followers_only_note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = insert(:followers_only_note, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data["id"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def article_activity_factory do
	article = insert(:article)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => article.data["actor"],
	"to" => article.data["to"],
	"object" => article.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => article.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def announce_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Announce",
	"actor" => note_activity.actor,
	"object" => note_activity.data["id"],
	"to" => [user.follower_address, note_activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => note_activity.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: user.ap_id,
	recipients: data["to"]
	}
	end

	def like_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Like",
	"object" => object.data["id"],
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Map.merge(attrs[:data_attrs] \|\| %{})

	%Pleroma.Activity{
	data: data
	}
	end

	def follow_activity_factory do
	follower = insert(:user)
	followed = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data,
	actor: follower.ap_id
	}
	end

	def report_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	activity = attrs[:activity] \|\| insert(:note_activity)
	state = attrs[:state] \|\| "open"

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Flag",
	"object" => [activity.actor, activity.data["id"]],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"to" => [],
	"cc" => [activity.actor],
	"context" => activity.data["context"],
	"state" => state
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"] ++ data["cc"]
	}
	end

	def question_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	question = attrs[:question] \|\| insert(:question, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :question, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => question.data["actor"],
	"to" => question.data["to"],
	"object" => question.data["id"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => question.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def oauth_app_factory do
	%Pleroma.Web.OAuth.App{
	client_name: sequence(:client_name, &"Some client #{&1}"),
	redirect_uris: "https://example.com/callback",
	scopes: ["read", "write", "follow", "push", "admin"],
	website: "https://example.com",
	client_id: Ecto.UUID.generate(),
	client_secret: "aaa;/&bbb"
	}
	end

	def instance_factory do
	%Pleroma.Instances.Instance{
	host: "domain.com",
	unreachable_since: nil
	}
	end

	def oauth_token_factory(attrs \\ %{}) do
	scopes = Map.get(attrs, :scopes, ["read"])
	oauth_app = Map.get_lazy(attrs, :app, fn -> insert(:oauth_app, scopes: scopes) end)
	user = Map.get_lazy(attrs, :user, fn -> build(:user) end)

	valid_until =
	Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10))

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	scopes: scopes,
	user: user,
	app: oauth_app,
	valid_until: valid_until
	}
	end

	def oauth_admin_token_factory(attrs \\ %{}) do
	user = Map.get_lazy(attrs, :user, fn -> build(:user, is_admin: true) end)

	scopes =
	attrs
	\|> Map.get(:scopes, ["admin"])
	\|> Kernel.++(["admin"])
	\|> Enum.uniq()

	attrs = Map.merge(attrs, %{user: user, scopes: scopes})
	oauth_token_factory(attrs)
	end

	def oauth_authorization_factory do
	%Pleroma.Web.OAuth.Authorization{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	scopes: ["read", "write", "follow", "push"],
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user),
	app: build(:oauth_app)
	}
	end

	def push_subscription_factory do
	%Pleroma.Web.Push.Subscription{
	user: build(:user),
	token: build(:oauth_token),
	endpoint: "https://example.com/example/1234",
	key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	key_p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
	data: %{}
	}
	end

	def notification_factory do
	%Pleroma.Notification{
	user: build(:user)
	}
	end

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end

	def registration_factory do
	user = insert(:user)

	%Pleroma.Registration{
	user: user,
	provider: "twitter",
	uid: "171799000",
	info: %{
	"name" => "John Doe",
	"email" => "john@doe.com",
	"nickname" => "johndoe",
	"description" => "My bio"
	}
	}
	end

	def config_factory(attrs \\ %{}) do
	%Pleroma.ConfigDB{
	key: sequence(:key, &String.to_atom("some_key_#{&1}")),
	group: :pleroma,
	value:
	sequence(
	:value,
	&%{another_key: "#{&1}somevalue", another: "#{&1}somevalue"}
	)
	}
	\|> merge_attributes(attrs)
	end

	def marker_factory do
	%Pleroma.Marker{
	user: build(:user),
	timeline: "notifications",
	lock_version: 0,
	last_read_id: "1"
	}
	end

	def mfa_token_factory do
	%Pleroma.MFA.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	authorization: build(:oauth_authorization),
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user)
	}
	end

	def filter_factory do
	%Pleroma.Filter{
	user: build(:user),
	filter_id: sequence(:filter_id, & &1),
	phrase: "cofe",
	context: ["home"]
	}
	end

	def announcement_factory(params \\ %{}) do
	data = Map.get(params, :data, %{})

	{_, params} = Map.pop(params, :data)

	%Pleroma.Announcement{
	data: Map.merge(%{"content" => "test announcement", "all_day" => false}, data)
	}
	\|> Map.merge(params)
	\|> Pleroma.Announcement.add_rendered_properties()
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 1:09 PM (20 h, 54 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1769503
Default Alt Text: (548 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions