No OneTemporary
Actions

Authored By

Unknown

Size

138 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 1ac67b618..5c436941a 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1415 +1,1419 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 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.Conversation
	alias Pleroma.Conversation.Participation
	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.ActivityPub.Utils
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker

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

	require Logger
	require Pleroma.Constants

	# For Announce activities, we filter the recipients based on following status for any actors
	# that match actual users. See issue #164 for more information about why this is necessary.
	defp get_recipients(%{"type" => "Announce"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients =
	Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil -> true
	user -> User.following?(user, actor)
	end
	end)

	{recipients, to, cc}
	end

	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_is_active(actor) do
	if not is_nil(actor) do
	with user <- User.get_cached_by_ap_id(actor),
	false <- user.deactivated do
	true
	else
	_e -> false
	end
	else
	true
	end
	end

	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 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

	def increase_replies_count_if_reply(_create_data), do: :noop

	def decrease_replies_count_if_reply(%Object{
	data: %{"inReplyTo" => reply_ap_id} = object
	}) do
	if is_public?(object) do
	Object.decrease_replies_count(reply_ap_id)
	end
	end

	def decrease_replies_count_if_reply(_object), do: :noop

	def increase_poll_votes_if_vote(%{
	"object" => %{"inReplyTo" => reply_ap_id, "name" => name},
	"type" => "Create"
	}) do
	Object.increase_vote_count(reply_ap_id, name)
	end

	def increase_poll_votes_if_vote(_create_data), do: :noop

	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 <- bypass_actor_check \|\| check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, 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) do
	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	# Splice in the child object if we have one.
	activity =
	if not is_nil(object) do
	Map.put(activity, :object, object)
	else
	activity
	end

	BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})

	Notification.create_notifications(activity)

	conversation = create_or_bump_conversation(activity, map["actor"])
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{: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}

	error ->
	{:error, error}
	end
	end

	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),
	Participation.mark_as_read(user, conversation) do
	{: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

	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
	conversation = Repo.preload(conversation, :participations),
	last_activity_id =
	fetch_latest_activity_id_for_context(conversation.ap_id, %{
	"user" => user,
	"blocking_user" => user
	}) do
	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	def stream_out_participations(_, _), do: :noop

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

	def stream_out(_activity) do
	:noop
	end

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

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_poll_votes_if_vote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

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

	{:error, message} ->
	{:error, message}
	end
	end

	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]

	with listen_data <-
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(listen_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, message} ->
	{:error, message}
	end
	end

	def accept(params) do
	accept_or_reject("Accept", params)
	end

	def reject(params) do
	accept_or_reject("Reject", params)
	end

	def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
	local = Map.get(params, :local, true)
	activity_id = Map.get(params, :activity_id, nil)

	with data <-
	%{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
	\|> Utils.maybe_put("id", activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	local = !(params[:local] == false)
	activity_id = params[:activity_id]

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	data <- Utils.maybe_put(data, "id", activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def react_with_emoji(user, object, emoji, options \\ []) do
	with local <- Keyword.get(options, :local, true),
	activity_id <- Keyword.get(options, :activity_id, nil),
	- Pleroma.Emoji.is_unicode_emoji?(emoji),
	+ true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
	reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
	{:ok, activity} <- insert(reaction_data, local),
	{:ok, object} <- add_emoji_reaction_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	+ else
	+ e -> {:error, e}
	end
	end

	def unreact_with_emoji(user, reaction_id, options \\ []) do
	with local <- Keyword.get(options, :local, true),
	activity_id <- Keyword.get(options, :activity_id, nil),
	user_ap_id <- user.ap_id,
	%Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
	object <- Object.normalize(reaction_activity),
	unreact_data <- make_undo_data(user, reaction_activity, activity_id),
	{:ok, activity} <- insert(unreact_data, local),
	{:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	+ else
	+ e -> {:error, e}
	end
	end

	# TODO: This is weird, maybe we shouldn't check here if we can make the activity.
	def like(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with nil <- get_existing_like(ap_id, object),
	like_data <- make_like_data(user, object, activity_id),
	{:ok, activity} <- insert(like_data, local),
	{:ok, object} <- add_like_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	%Activity{} = activity -> {:ok, activity, object}
	error -> {:error, error}
	end
	end

	def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
	with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
	unlike_data <- make_unlike_data(actor, like_activity, activity_id),
	{:ok, unlike_activity} <- insert(unlike_data, local),
	{:ok, _activity} <- Repo.delete(like_activity),
	{:ok, object} <- remove_like_from_object(like_activity, object),
	:ok <- maybe_federate(unlike_activity) do
	{:ok, unlike_activity, like_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true,
	public \\ true
	) do
	with true <- is_announceable?(object, user, public),
	announce_data <- make_announce_data(user, object, activity_id, public),
	{:ok, activity} <- insert(announce_data, local),
	{:ok, object} <- add_announce_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	error -> {:error, error}
	end
	end

	def unannounce(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
	unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
	{:ok, unannounce_activity} <- insert(unannounce_data, local),
	:ok <- maybe_federate(unannounce_activity),
	{:ok, _activity} <- Repo.delete(announce_activity),
	{:ok, object} <- remove_announce_from_object(announce_activity, object) do
	{:ok, unannounce_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity),
	_ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
	{:ok, activity}
	end
	end

	def unfollow(follower, followed, activity_id \\ nil, local \\ true) 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),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
	with data <- %{
	"to" => [follower_address],
	"type" => "Delete",
	"actor" => ap_id,
	"object" => %{"type" => "Person", "id" => ap_id}
	},
	{:ok, activity} <- insert(data, true, true, true),
	:ok <- maybe_federate(activity) do
	{:ok, user}
	end
	end

	def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options \\ []) do
	local = Keyword.get(options, :local, true)
	activity_id = Keyword.get(options, :activity_id, nil)
	actor = Keyword.get(options, :actor, actor)

	user = User.get_cached_by_ap_id(actor)
	to = (object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	with create_activity <- Activity.get_create_by_object_ap_id(id),
	data <-
	%{
	"type" => "Delete",
	"actor" => actor,
	"object" => id,
	"to" => to,
	"deleted_activity_id" => create_activity && create_activity.id
	}
	\|> maybe_put("id", activity_id),
	{:ok, activity} <- insert(data, local, false),
	{:ok, object, _create_activity} <- Object.delete(object),
	stream_out_participations(object, user),
	_ <- decrease_replies_count_if_reply(object),
	{:ok, _actor} <- decrease_note_count_if_public(user, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec block(User.t(), User.t(), String.t() \| nil, boolean) :: {:ok, Activity.t() \| nil}
	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
	unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])

	if unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)
	if follow_activity, do: unfollow(blocker, blocked, nil, local)
	end

	with true <- outgoing_blocks,
	block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	_e -> {:ok, nil}
	end
	end

	def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
	with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
	unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
	{:ok, activity} <- insert(unblock_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| any
	def 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),
	:ok <- maybe_federate(stripped_activity) do
	Enum.each(User.all_superusers(), fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	end
	end

	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local) 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

	defp fetch_activities_for_context_query(context, opts) do
	public = [Pleroma.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_recipients(recipients, opts["user"])
	\|> 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_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts = Map.drop(opts, ["user"])

	[Pleroma.Constants.as_public()]
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted()
	\|> Pagination.fetch_paginated(opts, 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
	query =
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)

	query
	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 @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
	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
	)
	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)

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(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_activity_ids", user.pinned_activities)

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

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	def fetch_instance_activities(params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("instance", params["instance"])

	fetch_activities([Pleroma.Constants.as_public()], params, :offset)
	\|> Enum.reverse()
	end

	defp user_activities_recipients(%{"godmode" => true}) do
	[]
	end

	defp user_activities_recipients(%{"reading_user" => reading_user}) do
	if reading_user do
	[Pleroma.Constants.as_public()] ++ [reading_user.ap_id \| User.following(reading_user)]
	else
	[Pleroma.Constants.as_public()]
	end
	end

	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_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

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

	defp restrict_tag_reject(query, _), do: query

	defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

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

	defp restrict_tag_all(query, _), do: query

	defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

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

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

	defp restrict_tag(query, _), do: query

	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_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" => val}) when val == "true" or val == "1" do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

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

	defp restrict_replies(query, _), do: query

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

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], 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' \\?\| ?)", activity.data, ^mutes)
	)

	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,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
	where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),
	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_unlisted(query) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Pleroma.Constants.as_public()]
	)
	)
	end

	defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
	from(activity in query, where: activity.id in ^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}) do
	users =
	from(
	u in User,
	select: u.ap_id,
	where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
	)
	\|> Repo.all()

	from(activity in query, where: activity.actor in ^users)
	end

	defp restrict_instance(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_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 fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts["muting_user"]
	ap_id_relations = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relations =
	ap_id_relations ++
	if opts["blocking_user"] && opts["blocking_user"] == source_user do
	[:block]
	else
	[]
	end

	preloaded_ap_ids = User.outgoing_relations_ap_ids(source_user, ap_id_relations)

	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
	{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])
	}

	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_tag(opts)
	\|> restrict_tag_reject(opts)
	\|> restrict_tag_all(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> Activity.restrict_deactivated_users()
	\|> exclude_poll_votes(opts)
	\|> exclude_visibility(opts)
	end

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

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

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), atom()) :: 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})
	\|> order_by([like, _, _], desc: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{"skip_order" => true}),
	pagination,
	:object_activity
	)
	end

	defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
	when is_list(list_memberships) and length(list_memberships) > 0 do
	Enum.map(activities, fn
	%{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
	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

	def 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
	^Pleroma.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

	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

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

	defp object_to_user_data(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

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

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)
	discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	user_data = %{
	ap_id: data["id"],
	ap_enabled: true,
	source_data: data,
	banner: banner,
	fields: fields,
	locked: locked,
	discoverable: discoverable,
	invisible: invisible,
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	bio: data["summary"],
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", [])
	}

	# nickname can be nil because of virtual actors
	user_data =
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end

	{:ok, user_data}
	end

	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

	defp maybe_update_follow_information(data) do
	with {:enabled, true} <-
	{:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
	{:ok, info} <- fetch_follow_information_for_user(data) do
	info = Map.merge(data[:info] \|\| %{}, info)
	Map.put(data, :info, info)
	else
	{:enabled, false} ->
	data

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

	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) do
	with {:ok, data} <- MRF.filter(data),
	{:ok, data} <- object_to_user_data(data) do
	{:ok, data}
	else
	e -> {:error, e}
	end
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data),
	data <- maybe_update_follow_information(data) do
	{:ok, data}
	else
	{:error, "Object has been deleted"} = e ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

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

	def make_user_from_ap_id(ap_id) do
	if _user = User.get_cached_by_ap_id(ap_id) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	User.insert_or_update_user(data)
	else
	e -> {:error, e}
	end
	end
	end

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

	# filter out broken threads
	def 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
	end
	diff --git a/test/fixtures/emoji-reaction-no-emoji.json b/test/fixtures/emoji-reaction-no-emoji.json
	new file mode 100644
	index 000000000..fff77b29b
	--- /dev/null
	+++ b/test/fixtures/emoji-reaction-no-emoji.json
	@@ -0,0 +1,30 @@
	+{
	+ "type": "EmojiReaction",
	+ "signature": {
	+ "type": "RsaSignature2017",
	+ "signatureValue": "fdxMfQSMwbC6wP6sh6neS/vM5879K67yQkHTbiT5Npr5wAac0y6+o3Ij+41tN3rL6wfuGTosSBTHOtta6R4GCOOhCaCSLMZKypnp1VltCzLDoyrZELnYQIC8gpUXVmIycZbREk22qWUe/w7DAFaKK4UscBlHDzeDVcA0K3Se5Sluqi9/Zh+ldAnEzj/rSEPDjrtvf5wGNf3fHxbKSRKFt90JvKK6hS+vxKUhlRFDf6/SMETw+EhwJSNW4d10yMUakqUWsFv4Acq5LW7l+HpYMvlYY1FZhNde1+uonnCyuQDyvzkff8zwtEJmAXC4RivO/VVLa17SmqheJZfI8oluVg==",
	+ "creator": "http://mastodon.example.org/users/admin#main-key",
	+ "created": "2018-02-17T18:57:49Z"
	+ },
	+ "object": "http://localtesting.pleroma.lol/objects/eb92579d-3417-42a8-8652-2492c2d4f454",
	+ "content": "~",
	+ "nickname": "lain",
	+ "id": "http://mastodon.example.org/users/admin#reactions/2",
	+ "actor": "http://mastodon.example.org/users/admin",
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams",
	+ "https://w3id.org/security/v1",
	+ {
	+ "toot": "http://joinmastodon.org/ns#",
	+ "sensitive": "as:sensitive",
	+ "ostatus": "http://ostatus.org#",
	+ "movedTo": "as:movedTo",
	+ "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
	+ "inReplyToAtomUri": "ostatus:inReplyToAtomUri",
	+ "conversation": "ostatus:conversation",
	+ "atomUri": "ostatus:atomUri",
	+ "Hashtag": "as:Hashtag",
	+ "Emoji": "toot:Emoji"
	+ }
	+ ]
	+}
	diff --git a/test/fixtures/emoji-reaction-too-long.json b/test/fixtures/emoji-reaction-too-long.json
	new file mode 100644
	index 000000000..31830d90c
	--- /dev/null
	+++ b/test/fixtures/emoji-reaction-too-long.json
	@@ -0,0 +1,30 @@
	+{
	+ "type": "EmojiReaction",
	+ "signature": {
	+ "type": "RsaSignature2017",
	+ "signatureValue": "fdxMfQSMwbC6wP6sh6neS/vM5879K67yQkHTbiT5Npr5wAac0y6+o3Ij+41tN3rL6wfuGTosSBTHOtta6R4GCOOhCaCSLMZKypnp1VltCzLDoyrZELnYQIC8gpUXVmIycZbREk22qWUe/w7DAFaKK4UscBlHDzeDVcA0K3Se5Sluqi9/Zh+ldAnEzj/rSEPDjrtvf5wGNf3fHxbKSRKFt90JvKK6hS+vxKUhlRFDf6/SMETw+EhwJSNW4d10yMUakqUWsFv4Acq5LW7l+HpYMvlYY1FZhNde1+uonnCyuQDyvzkff8zwtEJmAXC4RivO/VVLa17SmqheJZfI8oluVg==",
	+ "creator": "http://mastodon.example.org/users/admin#main-key",
	+ "created": "2018-02-17T18:57:49Z"
	+ },
	+ "object": "http://localtesting.pleroma.lol/objects/eb92579d-3417-42a8-8652-2492c2d4f454",
	+ "content": "👌👌",
	+ "nickname": "lain",
	+ "id": "http://mastodon.example.org/users/admin#reactions/2",
	+ "actor": "http://mastodon.example.org/users/admin",
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams",
	+ "https://w3id.org/security/v1",
	+ {
	+ "toot": "http://joinmastodon.org/ns#",
	+ "sensitive": "as:sensitive",
	+ "ostatus": "http://ostatus.org#",
	+ "movedTo": "as:movedTo",
	+ "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
	+ "inReplyToAtomUri": "ostatus:inReplyToAtomUri",
	+ "conversation": "ostatus:conversation",
	+ "atomUri": "ostatus:atomUri",
	+ "Hashtag": "as:Hashtag",
	+ "Emoji": "toot:Emoji"
	+ }
	+ ]
	+}
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index 5da358c43..0829a6ec2 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,2030 +1,2049 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	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

	clear_config([:instance, :max_remote_account_fields])

	describe "handle_incoming" do
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", Object.normalize(activity).data)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	@tag capture_log: true
	test "it fetches replied-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data = Map.put(data, "object", object)
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)
	returned_object = Object.normalize(returned_activity, false)

	assert activity =
	Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_object.data["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
	end

	test "it does not fetch replied-to activities beyond max_replies_depth" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data = Map.put(data, "object", object)

	with_mock Pleroma.Web.Federator,
	allowed_incoming_reply_depth?: fn _ -> false end do
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	returned_object = Object.normalize(returned_activity, false)

	refute Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_object.data["inReplyToAtomUri"] ==
	"https://shitposter.club/notice/2827873"
	end
	end

	test "it does not crash if the object in inReplyTo can't be fetched" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://404.site/whatever")

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

	assert capture_log(fn ->
	{:ok, _returned_activity} = Transmogrifier.handle_incoming(data)
	end) =~ "[error] Couldn't fetch \"https://404.site/whatever\", error: nil"
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object_data = Object.normalize(data["object"]).data

	assert object_data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object_data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object_data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert object_data["actor"] == "http://mastodon.example.org/users/admin"
	assert object_data["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object_data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object_data["sensitive"] == true

	user = User.get_cached_by_ap_id(object_data["actor"])

	assert user.note_count == 1
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert Enum.at(object.data["tag"], 2) == "moo"
	end

	test "it works for incoming questions" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity)

	assert Enum.all?(object.data["oneOf"], fn choice ->
	choice["name"] in [
	"Dunno",
	"Everyone knows that!",
	"25 char limit is dumb",
	"I can't even fit a funny"
	]
	end)
	end

	test "it works for incoming listens" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Listen",
	"id" => "http://mastodon.example.org/users/admin/listens/1234/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"object" => %{
	"type" => "Audio",
	"id" => "http://mastodon.example.org/users/admin/listens/1234",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"title" => "lain radio episode 1",
	"artist" => "lain",
	"album" => "lain radio",
	"length" => 180_000
	}
	}

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"
	assert object.data["artist"] == "lain"
	assert object.data["album"] == "lain radio"
	assert object.data["length"] == 180_000
	end

	test "it rewrites Note votes to Answers and increments vote counters on question activities" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "suya...",
	"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
	})

	object = Object.normalize(activity)

	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	answer_object = Object.normalize(activity)
	assert answer_object.data["type"] == "Answer"
	object = Object.get_by_ap_id(object.data["id"])

	assert Enum.any?(
	object.data["oneOf"],
	fn
	%{"name" => "suya..", "replies" => %{"totalItems" => 1}} -> true
	_ -> false
	end
	)
	end

	test "it works for incoming notices with contentMap" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert "test" in object.data["tag"]
	end

	test "it works for incoming notices with url not being a string (prismo)" do
	data = File.read!("test/fixtures/prismo-url-map.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["url"] == "https://prismo.news/posts/83"
	end

	test "it cleans up incoming notices which are not really DMs" do
	user = insert(:user)
	other_user = insert(:user)

	to = [user.ap_id, other_user.ap_id]

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)

	assert data["to"] == []
	assert data["cc"] == to

	object_data = Object.normalize(activity).data

	assert object_data["to"] == []
	assert object_data["cc"] == to
	end

	test "it works for incoming likes" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	assert data["object"] == activity.data["object"]
	end

	test "it works for incoming misskey likes, turning them into EmojiReactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/misskey-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == data["actor"]
	assert data["type"] == "EmojiReaction"
	assert data["id"] == data["id"]
	assert data["object"] == activity.data["object"]
	assert data["content"] == "🍮"
	end

	test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/misskey-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("_misskey_reaction", "⭐")

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == data["actor"]
	assert data["type"] == "EmojiReaction"
	assert data["id"] == data["id"]
	assert data["object"] == activity.data["object"]
	assert data["content"] == "⭐"
	end

	test "it works for incoming emoji reactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "EmojiReaction"
	assert data["id"] == "http://mastodon.example.org/users/admin#reactions/2"
	assert data["object"] == activity.data["object"]
	assert data["content"] == "👌"
	end

	+ test "it reject invalid emoji reactions" do
	+ user = insert(:user)
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
	+
	+ data =
	+ File.read!("test/fixtures/emoji-reaction-too-long.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", activity.data["object"])
	+
	+ assert :error = Transmogrifier.handle_incoming(data)
	+
	+ data =
	+ File.read!("test/fixtures/emoji-reaction-no-emoji.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", activity.data["object"])
	+
	+ assert :error = Transmogrifier.handle_incoming(data)
	+ end
	+
	test "it works for incoming emoji reaction undos" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
	{:ok, reaction_activity, _object} = CommonAPI.react_with_emoji(activity.id, user, "👌")

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", reaction_activity.data["id"])
	\|> Map.put("actor", user.ap_id)

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

	assert activity.actor == user.ap_id
	assert activity.data["id"] == data["id"]
	assert activity.data["type"] == "Undo"
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming unlikes with an existing like activity and a compact object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data["id"])
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming announces" do
	data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert Activity.get_create_by_object_ap_id(data["object"])
	end

	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

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

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] == activity.data["object"]

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

	test "it works for incoming announces with an inlined activity" do
	data =
	File.read!("test/fixtures/mastodon-announce-private.json")
	\|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	object = Object.normalize(data["object"])

	assert object.data["id"] == "http://mastodon.example.org/@admin/99541947525187368"
	assert object.data["content"] == "this is a private toot"
	end

	@tag capture_log: true
	test "it rejects incoming announces with an inlined activity from another origin" do
	data =
	File.read!("test/fixtures/bogus-mastodon-announce.json")
	\|> Poison.decode!()

	assert :error = Transmogrifier.handle_incoming(data)
	end

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", Object.normalize(activity).data["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert !is_nil(data["to"])
	assert !is_nil(data["cc"])
	end

	test "it strips internal likes" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

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

	object = Map.put(data["object"], "likes", likes)
	data = Map.put(data, "object", object)

	{:ok, %Activity{object: object}} = Transmogrifier.handle_incoming(data)

	refute Map.has_key?(object.data, "likes")
	end

	test "it strips internal reactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
	{:ok, _, _} = CommonAPI.react_with_emoji(activity.id, user, "📢")

	%{object: object} = Activity.get_by_id_with_object(activity.id)
	assert Map.has_key?(object.data, "reactions")
	assert Map.has_key?(object.data, "reaction_count")

	object_data = Transmogrifier.strip_internal_fields(object.data)
	refute Map.has_key?(object_data, "reactions")
	refute Map.has_key?(object_data, "reaction_count")
	end

	test "it works for incoming update activities" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	assert data["id"] == update_data["id"]

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works with alsoKnownAs" do
	{:ok, %Activity{data: %{"actor" => actor}}} =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Poison.decode!()
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == ["http://example.org/users/foo"]

	{:ok, _activity} =
	"test/fixtures/mastodon-update.json"
	\|> File.read!()
	\|> Poison.decode!()
	\|> Map.put("actor", actor)
	\|> Map.update!("object", fn object ->
	object
	\|> Map.put("actor", actor)
	\|> Map.put("id", actor)
	\|> Map.put("alsoKnownAs", [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	])
	end)
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	]
	end

	test "it works with custom profile fields" do
	{:ok, activity} =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Poison.decode!()
	\|> Transmogrifier.handle_incoming()

	user = User.get_cached_by_ap_id(activity.actor)

	assert User.fields(user) == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "foo1", "value" => "bar1"}
	]

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert User.fields(user) == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	Pleroma.Config.put([:instance, :max_remote_account_fields], 2)

	update_data =
	put_in(update_data, ["object", "attachment"], [
	%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
	%{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
	%{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
	])

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert User.fields(user) == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	update_data = put_in(update_data, ["object", "attachment"], [])

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

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

	test "it works for incoming update activities which lock the account" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.locked == true
	end

	test "it works for incoming deletes" do
	activity = insert(:note_activity)
	deleting_user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"])

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("actor", deleting_user.ap_id)

	{:ok, %Activity{actor: actor, local: false, data: %{"id" => id}}} =
	Transmogrifier.handle_incoming(data)

	assert id == data["id"]
	refute Activity.get_by_id(activity.id)
	assert actor == deleting_user.ap_id
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"])

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

	assert capture_log(fn ->
	:error = Transmogrifier.handle_incoming(data)
	end) =~
	"[error] Could not decode user at fetch http://mastodon.example.org/users/gargron, {:error, :nxdomain}"

	assert Activity.get_by_id(activity.id)
	end

	@tag capture_log: true
	test "it works for incoming user deletes" do
	%{ap_id: ap_id} = insert(:user, ap_id: "http://mastodon.example.org/users/admin")

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	\|> Poison.decode!()

	{:ok, _} = Transmogrifier.handle_incoming(data)
	ObanHelpers.perform_all()

	refute User.get_cached_by_ap_id(ap_id)
	end

	test "it fails for incoming user deletes with spoofed origin" do
	%{ap_id: ap_id} = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	\|> Poison.decode!()
	\|> Map.put("actor", ap_id)

	assert capture_log(fn ->
	assert :error == Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"

	assert User.get_cached_by_ap_id(ap_id)
	end

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

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

	{:ok, %Activity{data: announce_data, local: false}} =
	Transmogrifier.handle_incoming(announce_data)

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert object_data = data["object"]
	assert object_data["type"] == "Announce"
	assert object_data["object"] == activity.data["object"]

	assert object_data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

	test "it works for incomming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.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")
	\|> Poison.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 works for incoming follows to locked account" do
	pending_follower = insert(:user, ap_id: "http://mastodon.example.org/users/admin")
	user = insert(:user, locked: true)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Follow"
	assert data["object"] == user.ap_id
	assert data["state"] == "pending"
	assert data["actor"] == "http://mastodon.example.org/users/admin"

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

	test "it works for incoming blocks" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_cached_by_ap_id(data["actor"])

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

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

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

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_cached_by_ap_id(data["actor"])
	blocked = User.get_cached_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

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

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

	block_data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Block"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_cached_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

	assert activity.data["id"] == accept_data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which were orphaned" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are orphaned" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	reject_data =
	Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(reject_data)
	refute activity.local
	assert activity.data["id"] == reject_data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follower} = User.follow(follower, followed)
	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Map.put("id", "")

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it remaps video URLs as attachments if necessary" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	attachment = %{
	"type" => "Link",
	"mediaType" => "video/mp4",
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"size" => 5_015_880,
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	],
	"width" => 480
	}

	assert object.data["url"] ==
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"

	assert object.data["attachment"] == [attachment]
	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)

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

	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 correctly processes messages with non-array to field" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"type" => "Create",
	"object" => %{
	"content" => "blah blah blah",
	"type" => "Note",
	"attributedTo" => user.ap_id,
	"inReplyTo" => nil
	},
	"actor" => user.ap_id
	}

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

	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with non-array cc field" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => user.follower_address,
	"cc" => "https://www.w3.org/ns/activitystreams#Public",
	"type" => "Create",
	"object" => %{
	"content" => "blah blah blah",
	"type" => "Note",
	"attributedTo" => user.ap_id,
	"inReplyTo" => nil
	},
	"actor" => user.ap_id
	}

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

	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["cc"]
	assert [user.follower_address] == activity.data["to"]
	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
	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"})

	{: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"
	}

	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end

	test "it adds the sensitive property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["sensitive"]
	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"] ==
	Pleroma.Web.ActivityPub.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:"})

	{: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"]["context_id"])
	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"]["context_id"])
	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
	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, "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 "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

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

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

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

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end

	test "Rewrites Answers to Notes" do
	user = insert(:user)

	{:ok, poll_activity} =
	CommonAPI.post(user, %{
	"status" => "suya...",
	"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
	})

	poll_object = Object.normalize(poll_activity)
	# TODO: Replace with CommonAPI vote creation when implemented
	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], poll_object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)

	assert data["object"]["type"] == "Note"
	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)
	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)
	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)

	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_in_reply_to/2" do
	clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	[data: data]
	end

	test "returns not modified object when hasn't containts inReplyTo field", %{data: data} do
	assert Transmogrifier.fix_in_reply_to(data) == data
	end

	test "returns object with inReplyToAtomUri when denied incoming reply", %{data: data} do
	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)

	object_with_reply =
	Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873")

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == "https://shitposter.club/notice/2827873"
	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	object_with_reply =
	Map.put(data["object"], "inReplyTo", %{"id" => "https://shitposter.club/notice/2827873"})

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == %{"id" => "https://shitposter.club/notice/2827873"}
	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	object_with_reply =
	Map.put(data["object"], "inReplyTo", ["https://shitposter.club/notice/2827873"])

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == ["https://shitposter.club/notice/2827873"]
	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	object_with_reply = Map.put(data["object"], "inReplyTo", [])
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == []
	assert modified_object["inReplyToAtomUri"] == ""
	end

	@tag capture_log: true
	test "returns modified object when allowed incoming reply", %{data: data} do
	object_with_reply =
	Map.put(
	data["object"],
	"inReplyTo",
	"https://shitposter.club/notice/2827873"
	)

	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 5)
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)

	assert modified_object["inReplyTo"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"

	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	assert modified_object["conversation"] ==
	"tag:shitposter.club,2017-05-05:objectType=thread:nonce=3c16e9c2681f6d26"

	assert modified_object["context"] ==
	"tag:shitposter.club,2017-05-05:objectType=thread:nonce=3c16e9c2681f6d26"
	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 "fixes data for video object" do
	object = %{
	"type" => "Video",
	"url" => [
	%{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	},
	%{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peertube46fb-ad81-2d4c2d1630e3-240.mp4"
	},
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d1630e3"
	},
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d16377-42"
	}
	]
	}

	assert Transmogrifier.fix_url(object) == %{
	"attachment" => [
	%{
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"type" => "Link"
	}
	],
	"type" => "Video",
	"url" => "https://peertube.-2d4c2d1630e3"
	}
	end

	test "fixes url for not Video object" do
	object = %{
	"type" => "Text",
	"url" => [
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d1630e3"
	},
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d16377-42"
	}
	]
	}

	assert Transmogrifier.fix_url(object) == %{
	"type" => "Text",
	"url" => "https://peertube.-2d4c2d1630e3"
	}

	assert Transmogrifier.fix_url(%{"type" => "Text", "url" => []}) == %{
	"type" => "Text",
	"url" => ""
	}
	end

	test "retunrs not 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://shitposter.club/notice/2827873")
	end
	end

	describe "fix_attachments/1" do
	test "returns not modified object" do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_attachments(data) == data
	end

	test "returns modified object when attachment is map" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => %{
	"mediaType" => "video/mp4",
	"url" => "https://peertube.moe/stat-480.mp4"
	}
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"url" => [
	%{
	"href" => "https://peertube.moe/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end

	test "returns modified object when attachment is list" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => [
	%{"mediaType" => "video/mp4", "url" => "https://pe.er/stat-480.mp4"},
	%{"mimeType" => "video/mp4", "href" => "https://pe.er/stat-480.mp4"}
	]
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	},
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"mimeType" => "video/mp4",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end
	end

	describe "fix_emoji/1" do
	test "returns not modified object when object not contains tags" do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_emoji(data) == data
	end

	test "returns object with emoji when object contains list tags" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => [
	%{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}},
	%{"type" => "Hashtag"}
	]
	}) == %{
	"emoji" => %{"bib" => "/test"},
	"tag" => [
	%{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"},
	%{"type" => "Hashtag"}
	]
	}
	end

	test "returns object with emoji when object contains map tag" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}}
	}) == %{
	"emoji" => %{"bib" => "/test"},
	"tag" => %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"}
	}
	end
	end
	end
	diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
	index f8963e42e..8fa0c6faa 100644
	--- a/test/web/common_api/common_api_test.exs
	+++ b/test/web/common_api/common_api_test.exs
	@@ -1,638 +1,640 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	clear_config([:instance, :safe_dm_mentions])
	clear_config([:instance, :limit])
	clear_config([:instance, :max_pinned_statuses])

	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)
	Pleroma.Config.put([: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)

	assert object.data["tag"] == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})

	assert Object.normalize(activity).data["emoji"]["firefox"]
	end

	test "it adds emoji when updating profiles" do
	user = insert(:user, %{name: ":firefox:"})

	{:ok, activity} = CommonAPI.update(user)
	user = User.get_cached_by_ap_id(user.ap_id)
	[firefox] = user.source_data["tag"]

	assert firefox["name"] == ":firefox:"

	assert Pleroma.Constants.as_public() in activity.recipients
	end

	describe "posting" do
	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)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	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)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	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 "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 returns error when character limit is exceeded" do
	Pleroma.Config.put([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{"status" => "foobar"})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)
	\|> NaiveDateTime.add(1_000_000, :second)

	assert {:ok, activity} =
	CommonAPI.post(user, %{"status" => "chai", "expires_in" => 1_000_000})

	assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id)
	assert expiration.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"] == "👍"

	- # TODO: test error case.
	+ {: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)

	{: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"]
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.repeat(activity.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)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.favorite(activity.id, user)
	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{} = activity, object} = CommonAPI.repeat(activity.id, user)
	{:ok, ^activity, ^object} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{} = activity, object} = CommonAPI.favorite(activity.id, user)
	{:ok, ^activity, ^object} = CommonAPI.favorite(activity.id, user)
	end
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	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, "Could not pin"} = 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, "You have already pinned the maximum number of statuses"} =
	CommonAPI.pin(activity_two.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	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_activities: []} = user
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert 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 "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	"account_id" => target_user.id,
	"comment" => comment,
	"status_ids" => [activity.id]
	}

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

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, activity_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert activity_id == activity.data["id"]
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel very offended!",
	"status_ids" => [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "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
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_three} = ActivityPub.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, locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_three} = ActivityPub.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
	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)

	{: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)

	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)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 8:38 AM (12 h, 20 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803913
Default Alt Text: (138 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions