No OneTemporary
Actions

Size

92 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/pipeline-remote-dm-conversations.fix b/changelog.d/pipeline-remote-dm-conversations.fix
	new file mode 100644
	index 000000000..bf5c93e66
	--- /dev/null
	+++ b/changelog.d/pipeline-remote-dm-conversations.fix
	@@ -0,0 +1 @@
	+Conversations and participations are now created for incoming remote direct messages, not only for locally posted ones.
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index 65c4867a5..c41216b87 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,668 +1,694 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.SideEffects do
	@moduledoc """
	This module looks at an inserted object and executes the side effects that it
	implies. For example, a `Like` activity will increase the like count on the
	liked object, a `Follow` activity will add the user to the follower
	collection, and so on.
	"""
	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	+ alias Pleroma.Conversation
	+ alias Pleroma.Conversation.Participation
	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Streamer
	alias Pleroma.Workers.PollWorker

	require Pleroma.Constants
	require Logger

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

	@behaviour Pleroma.Web.ActivityPub.SideEffects.Handling

	defp ap_streamer, do: Pleroma.Config.get([:side_effects, :ap_streamer], ActivityPub)

	@impl true
	def handle(object, meta \\ [])

	# Task this handles
	# - Follows
	# - Sends a notification
	@impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Accept",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _follower, followed} <-
	FollowingRelationship.update(follower, followed, :follow_accept) do
	Notification.update_notification_type(followed, follow_activity)
	end

	{:ok, object, meta}
	end

	# Task this handles
	# - Rejects all existing follow activities for this person
	# - Updates the follow state
	# - Dismisses notification
	@impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Reject",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, _follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject") do
	FollowingRelationship.update(follower, followed, :follow_reject)
	Notification.dismiss(follow_activity)
	end

	{:ok, object, meta}
	end

	# Tasks this handle
	# - Follows if possible
	# - Sends a notification
	# - Generates accept or reject if appropriate
	@impl true
	def handle(
	%{
	data: %{
	"id" => follow_id,
	"type" => "Follow",
	"object" => followed_user,
	"actor" => following_user
	}
	} = object,
	meta
	) do
	with %User{} = follower <- User.get_cached_by_ap_id(following_user),
	%User{} = followed <- User.get_cached_by_ap_id(followed_user),
	{_, {:ok, _, _}, _, _} <-
	{:following, User.follow(follower, followed, :follow_pending), follower, followed} do
	if followed.local && !followed.is_locked do
	{:ok, accept_data, _} = Builder.accept(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(accept_data, local: true)
	end
	else
	{:following, {:error, _}, _follower, followed} ->
	{:ok, reject_data, _} = Builder.reject(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(reject_data, local: true)

	_ ->
	nil
	end

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)

	updated_object = Activity.get_by_ap_id(follow_id)

	{:ok, updated_object, meta}
	end

	# Tasks this handles:
	# - Unfollow and block
	@impl true
	def handle(
	%{data: %{"type" => "Block", "object" => blocked_user, "actor" => blocking_user}} =
	object,
	meta
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocking_user),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked_user) do
	User.block(blocker, blocked, Enum.into(meta, %{}))
	end

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Update the user
	# - Update a non-user object (Note, Question, etc.)
	#
	# For a local user, we also get a changeset with the full information, so we
	# can update non-federating, non-activitypub settings as well.
	@impl true
	def handle(%{data: %{"type" => "Update", "object" => updated_object}} = object, meta) do
	updated_object_id = updated_object["id"]

	with {_, true} <- {:has_id, is_binary(updated_object_id)},
	%{"type" => type} <- updated_object,
	{_, is_user} <- {:is_user, type in Pleroma.Constants.actor_types()} do
	if is_user do
	handle_update_user(object, meta)
	else
	handle_update_object(object, meta)
	end
	else
	_ ->
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	@impl true
	def handle(%{data: %{"type" => "Like"}} = object, meta) do
	liked_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_like_to_object(object, liked_object)

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Increase the user note count
	# - Increase the reply count
	# - Increase replies count
	# - Set up ActivityExpiration
	# - Set up notifications
	# - Index incoming posts for search (if needed)
	@impl true
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, object, meta} <- handle_object_creation(meta[:object_data], activity, meta),
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	{:ok, notifications} = Notification.create_notifications(activity)
	{:ok, _user} = ActivityPub.increase_note_count_if_public(user, object)
	{:ok, _user} = ActivityPub.update_last_status_at_if_public(user, object)

	if in_reply_to = object.data["type"] != "Answer" && object.data["inReplyTo"] do
	Object.increase_replies_count(in_reply_to)
	end

	if quote_url = object.data["quoteUrl"] do
	Object.increase_quotes_count(quote_url)
	end

	reply_depth = (meta[:depth] \|\| 0) + 1

	# FIXME: Force inReplyTo to replies
	if Pleroma.Web.Federator.allowed_thread_distance?(reply_depth) and
	object.data["replies"] != nil do
	for reply_id <- object.data["replies"] do
	Pleroma.Workers.RemoteFetcherWorker.new(%{
	"op" => "fetch_remote",
	"id" => reply_id,
	"depth" => reply_depth
	})
	\|> Oban.insert()
	end
	end

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)

	Pleroma.Search.add_to_index(Map.put(activity, :object, object))

	Utils.maybe_handle_group_posts(activity)

	meta =
	meta
	\|> add_notifications(notifications)
	\|> add_stream_out(activity)
	+ \|> handle_conversation(activity)

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

	# Tasks this handles:
	# - Add announce to object
	# - Set up notification
	# - Stream out the announce
	@impl true
	def handle(%{data: %{"type" => "Announce"}} = object, meta) do
	announced_object = Object.get_by_ap_id(object.data["object"])
	user = User.get_cached_by_ap_id(object.data["actor"])

	Utils.add_announce_to_object(object, announced_object)

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)
	\|> maybe_add_stream_out(object, !User.internal?(user))

	{:ok, object, meta}
	end

	@impl true
	def handle(%{data: %{"type" => "Undo", "object" => undone_object}} = object, meta) do
	with undone_object <- Activity.get_by_ap_id(undone_object),
	:ok <- handle_undoing(undone_object) do
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	@impl true
	def handle(%{data: %{"type" => "EmojiReact"}} = object, meta) do
	reacted_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_emoji_reaction_to_object(object, reacted_object)

	{:ok, notifications} = Notification.create_notifications(object)

	meta =
	meta
	\|> add_notifications(notifications)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	# - Removes posts from search index (if needed)
	@impl true
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, fetch: false) \|\|
	User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	with {_, {:ok, deleted_object, _activity}} <- {:object, Object.delete(deleted_object)},
	{_, actor} when is_binary(actor) <- {:actor, deleted_object.data["actor"]},
	{_, %User{} = user} <- {:user, User.get_cached_by_ap_id(actor)} do
	User.remove_pinned_object_id(user, deleted_object.data["id"])

	{:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)

	if in_reply_to = deleted_object.data["inReplyTo"] do
	Object.decrease_replies_count(in_reply_to)
	end

	if quote_url = deleted_object.data["quoteUrl"] do
	Object.decrease_quotes_count(quote_url)
	end

	MessageReference.delete_for_object(deleted_object)

	meta =
	meta
	\|> add_stream_out(object)
	\|> add_stream_out_participations(deleted_object, user)

	{:ok, meta}
	else
	{:actor, _} ->
	@logger.error("The object doesn't have an actor: #{inspect(deleted_object)}")
	:no_object_actor

	{:user, _} ->
	@logger.error(
	"The object's actor could not be resolved to a user: #{inspect(deleted_object)}"
	)

	:no_object_user

	{:object, _} ->
	@logger.error("The object could not be deleted: #{inspect(deleted_object)}")
	{:error, object}
	end

	%User{} ->
	with {:ok, _} <- User.delete(deleted_object) do
	{:ok, meta}
	end
	end

	case result do
	{:ok, meta} ->
	# Only remove from index when deleting actual objects, not users or anything else
	with %Pleroma.Object{} <- deleted_object do
	Pleroma.Search.remove_from_index(deleted_object)
	end

	{:ok, object, meta}

	error ->
	{:error, error}
	end
	end

	# Tasks this handles:
	# - adds pin to user
	# - removes expiration job for pinned activity, if was set for expiration
	@impl true
	def handle(%{data: %{"type" => "Add"} = data} = object, meta) do
	with %User{} = user <- User.get_cached_by_ap_id(data["actor"]),
	{:ok, _user} <- User.add_pinned_object_id(user, data["object"]) do
	# if pinned activity was scheduled for deletion, we remove job
	if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(meta[:activity_id]) do
	Oban.cancel_job(expiration.id)
	end

	{:ok, object, meta}
	else
	nil ->
	{:error, :user_not_found}

	{:error, changeset} ->
	if changeset.errors[:pinned_objects] do
	{:error, :pinned_statuses_limit_reached}
	else
	changeset.errors
	end
	end
	end

	# Tasks this handles:
	# - removes pin from user
	# - removes corresponding Add activity
	# - if activity had expiration, recreates activity expiration job
	@impl true
	def handle(%{data: %{"type" => "Remove"} = data} = object, meta) do
	with %User{} = user <- User.get_cached_by_ap_id(data["actor"]),
	{:ok, _user} <- User.remove_pinned_object_id(user, data["object"]) do
	data["object"]
	\|> Activity.add_by_params_query(user.ap_id, user.featured_address)
	\|> Repo.delete_all()

	# if pinned activity was scheduled for deletion, we reschedule it for deletion
	if meta[:expires_at] do
	# MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
	{:ok, expires_at} =
	Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast(meta[:expires_at])

	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: meta[:activity_id]
	},
	scheduled_at: expires_at
	)
	end

	{:ok, object, meta}
	else
	nil -> {:error, :user_not_found}
	error -> error
	end
	end

	# Nothing to do
	@impl true
	def handle(object, meta) do
	{:ok, object, meta}
	end

	defp handle_update_user(
	%{data: %{"type" => "Update", "object" => updated_object}} = object,
	meta
	) do
	if changeset = Keyword.get(meta, :user_update_changeset) do
	changeset
	\|> User.update_and_set_cache()
	else
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(updated_object)

	User.get_by_ap_id(updated_object["id"])
	\|> User.remote_user_changeset(new_user_data)
	\|> User.update_and_set_cache()
	end

	{:ok, object, meta}
	end

	defp handle_update_object(
	%{data: %{"type" => "Update", "object" => updated_object}} = object,
	meta
	) do
	orig_object_ap_id = updated_object["id"]
	orig_object = Object.get_by_ap_id(orig_object_ap_id)
	orig_object_data = Map.get(orig_object, :data)

	updated_object =
	if meta[:local] do
	# If this is a local Update, we don't process it by transmogrifier,
	# so we use the embedded object as-is.
	updated_object
	else
	meta[:object_data]
	end

	- if orig_object_data["type"] in Pleroma.Constants.updatable_object_types() do
	- {:ok, _, updated} =
	- Object.Updater.do_update_and_invalidate_cache(orig_object, updated_object)
	+ with true <- orig_object_data["type"] in Pleroma.Constants.updatable_object_types(),
	+ {:ok, _, true} <-
	+ Object.Updater.do_update_and_invalidate_cache(orig_object, updated_object) do
	+ {:ok, notifications} = Notification.create_notifications(object)

	- if updated do
	- object
	- \|> Activity.normalize()
	- \|> ActivityPub.notify_and_stream()
	- end
	+ meta =
	+ meta
	+ \|> add_notifications(notifications)
	+ \|> add_stream_out(Activity.normalize(object))
	+ \|> handle_conversation(Activity.get_create_by_object_ap_id_with_object(orig_object_ap_id))
	+
	+ {:ok, object, meta}
	+ else
	+ _ -> {:ok, object, meta}
	end
	+ end

	- {:ok, object, meta}
	+ # Creates or bumps the conversation of a direct message, marks it as read for
	+ # the author and queues the participations for streaming.
	+ defp handle_conversation(meta, %Activity{} = activity) do
	+ with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	+ %User{} = author <- User.get_cached_by_ap_id(activity.actor) do
	+ Participation.mark_as_read(author, conversation)
	+
	+ participations =
	+ conversation
	+ \|> Repo.preload([participations: :user], force: true)
	+ \|> Map.get(:participations)
	+
	+ add_streamables(meta, [{"participation", participations}])
	+ else
	+ _ -> meta
	+ end
	end

	+ defp handle_conversation(meta, _), do: meta
	+
	def handle_object_creation(%{"type" => "ChatMessage"} = object, _activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	actor = User.get_cached_by_ap_id(object.data["actor"])
	recipient = User.get_cached_by_ap_id(hd(object.data["to"]))

	streamables =
	[[actor, recipient], [recipient, actor]]
	\|> Enum.uniq()
	\|> Enum.map(fn [user, other_user] ->
	if user.local do
	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	{:ok, cm_ref} = MessageReference.create(chat, object, user.ap_id != actor.ap_id)

	@cachex.put(
	:chat_message_id_idempotency_key_cache,
	cm_ref.id,
	meta[:idempotency_key]
	)

	{
	["user", "user:pleroma_chat"],
	{user, %{cm_ref \| chat: chat, object: object}}
	}
	end
	end)
	\|> Enum.filter(& &1)

	meta =
	meta
	\|> add_streamables(streamables)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Question"} = object, activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	PollWorker.schedule_poll_end(activity)
	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Answer"} = object_map, _activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object_map, meta) do
	Object.increase_vote_count(
	object.data["inReplyTo"],
	object.data["name"],
	object.data["actor"]
	)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => objtype} = object, _activity, meta)
	when objtype in ~w[Audio Video Image Event Article Note Page] do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	{:ok, object, meta}
	end
	end

	# Nothing to do
	def handle_object_creation(object, _activity, meta) do
	{:ok, object, meta}
	end

	defp undo_like(nil, object), do: delete_object(object)

	defp undo_like(%Object{} = liked_object, object) do
	with {:ok, _} <- Utils.remove_like_from_object(object, liked_object) do
	delete_object(object)
	end
	end

	def handle_undoing(%{data: %{"type" => "Like"}} = object) do
	object.data["object"]
	\|> Object.get_by_ap_id()
	\|> undo_like(object)
	end

	def handle_undoing(%{data: %{"type" => "EmojiReact"}} = object) do
	with %Object{} = reacted_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_emoji_reaction_from_object(object, reacted_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "Announce"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_announce_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(
	%{data: %{"type" => "Block", "actor" => blocker, "object" => blocked}} = object
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocker),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, _} <- User.unblock(blocker, blocked),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(object), do: {:error, ["don't know how to handle", object]}

	@spec delete_object(Activity.t()) :: :ok \| {:error, Ecto.Changeset.t()}
	defp delete_object(object) do
	with {:ok, _} <- Repo.delete(object), do: :ok
	end

	defp stream_notifications(meta) do
	Keyword.get(meta, :notifications, [])
	\|> Notification.stream()

	meta
	end

	defp send_streamables(meta) do
	Keyword.get(meta, :streamables, [])
	\|> Enum.each(fn {topics, items} ->
	Streamer.stream(topics, items)
	end)

	meta
	end

	defp stream_out_activities(meta) do
	Keyword.get(meta, :stream_out, [])
	\|> Enum.each(fn activity -> ap_streamer().stream_out(activity) end)

	meta
	end

	defp stream_out_participations(meta) do
	Keyword.get(meta, :stream_out_participations, [])
	\|> Enum.each(fn {object, user} -> ap_streamer().stream_out_participations(object, user) end)

	meta
	end

	# Streaming is deferred until after the transaction commits, so that the
	# streamer processes (which use their own database connections) can see the
	# persisted activity and its side effects.
	defp add_stream_out(meta, activity) do
	Keyword.update(meta, :stream_out, [activity], &(&1 ++ [activity]))
	end

	defp maybe_add_stream_out(meta, activity, true), do: add_stream_out(meta, activity)
	defp maybe_add_stream_out(meta, _activity, false), do: meta

	defp add_stream_out_participations(meta, object, user) do
	Keyword.update(meta, :stream_out_participations, [{object, user}], &(&1 ++ [{object, user}]))
	end

	defp add_streamables(meta, streamables) do
	existing = Keyword.get(meta, :streamables, [])

	meta
	\|> Keyword.put(:streamables, streamables ++ existing)
	end

	defp add_notifications(meta, notifications) do
	existing = Keyword.get(meta, :notifications, [])

	meta
	\|> Keyword.put(:notifications, notifications ++ existing)
	end

	@impl true
	def handle_after_transaction(meta) do
	meta
	\|> stream_out_activities()
	\|> stream_notifications()
	\|> send_streamables()
	\|> stream_out_participations()
	end
	end
	diff --git a/test/pleroma/web/activity_pub/side_effects_test.exs b/test/pleroma/web/activity_pub/side_effects_test.exs
	index 0fd9abd6a..ac927a838 100644
	--- a/test/pleroma/web/activity_pub/side_effects_test.exs
	+++ b/test/pleroma/web/activity_pub/side_effects_test.exs
	@@ -1,1060 +1,1134 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	+ alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ActivityPubMock
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.ActivityDraft

	import Mock
	import Mox
	import Pleroma.Factory

	defp get_announces_of_object(%{data: %{"id" => id}} = _object) do
	Pleroma.Activity.Queries.by_type("Announce")
	\|> Pleroma.Activity.Queries.by_object_id(id)
	\|> Pleroma.Repo.all()
	end

	describe "handle_after_transaction" do
	test "it streams out notifications and streams" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert [notification] = meta[:notifications]

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	}
	]) do
	SideEffects.handle_after_transaction(meta)

	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	assert_enqueued(
	worker: "Pleroma.Workers.WebPusherWorker",
	args: %{"notification_id" => notification.id, "op" => "web_push"}
	)
	end
	end
	end

	describe "blocking users" do
	setup do
	user = insert(:user)
	blocked = insert(:user)
	User.follow(blocked, user)
	User.follow(user, blocked)

	{:ok, block_data, []} = Builder.block(user, blocked)
	{:ok, block, _meta} = ActivityPub.persist(block_data, local: true)

	%{user: user, blocked: blocked, block: block}
	end

	test "it unfollows and blocks", %{user: user, blocked: blocked, block: block} do
	assert User.following?(user, blocked)
	assert User.following?(blocked, user)

	{:ok, _, _} = SideEffects.handle(block)

	refute User.following?(user, blocked)
	refute User.following?(blocked, user)
	assert User.blocks?(user, blocked)
	end

	test "it updates following relationship", %{user: user, blocked: blocked, block: block} do
	{:ok, _, _} = SideEffects.handle(block)

	refute Pleroma.FollowingRelationship.get(user, blocked)
	assert User.get_follow_state(user, blocked) == nil
	assert User.get_follow_state(blocked, user) == nil
	assert User.get_follow_state(user, blocked, nil) == nil
	assert User.get_follow_state(blocked, user, nil) == nil
	end

	test "it blocks but does not unfollow if the relevant setting is set", %{
	user: user,
	blocked: blocked,
	block: block
	} do
	clear_config([:activitypub, :unfollow_blocked], false)
	assert User.following?(user, blocked)
	assert User.following?(blocked, user)

	{:ok, _, _} = SideEffects.handle(block)

	refute User.following?(user, blocked)
	assert User.following?(blocked, user)
	assert User.blocks?(user, blocked)
	end
	end

	describe "update users" do
	setup do
	user = insert(:user, local: false)

	{:ok, update_data, []} =
	Builder.update(user, %{"id" => user.ap_id, "type" => "Person", "name" => "new name!"})

	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	%{user: user, update_data: update_data, update: update}
	end

	test "it updates the user", %{user: user, update: update} do
	{:ok, _, _} = SideEffects.handle(update)
	user = User.get_by_id(user.id)
	assert user.name == "new name!"
	end

	test "it uses a given changeset to update", %{user: user, update: update} do
	changeset = Ecto.Changeset.change(user, %{default_scope: "direct"})

	assert user.default_scope == "public"
	{:ok, _, _} = SideEffects.handle(update, user_update_changeset: changeset)
	user = User.get_by_id(user.id)
	assert user.default_scope == "direct"
	end
	end

	describe "update notes" do
	setup do
	make_time = fn ->
	Pleroma.Web.ActivityPub.Utils.make_date()
	end

	user = insert(:user)
	note = insert(:note, user: user, data: %{"published" => make_time.()})
	_note_activity = insert(:note_activity, note: note)

	updated_note =
	note.data
	\|> Map.put("summary", "edited summary")
	\|> Map.put("content", "edited content")
	\|> Map.put("updated", make_time.())

	{:ok, update_data, []} = Builder.update(user, updated_note)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	%{
	user: user,
	note: note,
	object_id: note.id,
	update_data: update_data,
	update: update,
	updated_note: updated_note
	}
	end

	test "it updates the note", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	updated_time = updated_note["updated"]

	new_note = Pleroma.Object.get_by_id(object_id)

	assert %{
	"summary" => "edited summary",
	"content" => "edited content",
	"updated" => ^updated_time
	} = new_note.data
	end

	+ test "it streams out the update only after the transaction", %{
	+ update: update,
	+ updated_note: updated_note
	+ } do
	+ ActivityPubMock
	+ \|> expect(:stream_out, 0, fn _ -> nil end)
	+
	+ {:ok, update, meta} = SideEffects.handle(update, object_data: updated_note)
	+
	+ verify!()
	+
	+ update_id = update.id
	+
	+ ActivityPubMock
	+ \|> expect(:stream_out, fn %Activity{id: ^update_id, object: %Object{}} -> nil end)
	+
	+ SideEffects.handle_after_transaction(meta)
	+ end
	+
	+ test "it does not stream out rejected updates", %{
	+ update: update,
	+ updated_note: updated_note
	+ } do
	+ ActivityPubMock
	+ \|> expect(:stream_out, 0, fn _ -> nil end)
	+
	+ updated_note = Map.delete(updated_note, "updated")
	+ {:ok, _update, meta} = SideEffects.handle(update, object_data: updated_note)
	+ SideEffects.handle_after_transaction(meta)
	+ end
	+
	test "it rejects updates with no updated attribute in object", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	updated_note = Map.drop(updated_note, ["updated"])
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it rejects updates with updated attribute older than what we have in the original object",
	%{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, creation_time, _} = DateTime.from_iso8601(old_note.data["published"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(creation_time, -10)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it rejects updates with updated attribute older than the last Update", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, creation_time, _} = DateTime.from_iso8601(old_note.data["published"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(creation_time, +10)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)

	old_note = Pleroma.Object.get_by_id(object_id)
	{:ok, update_time, _} = DateTime.from_iso8601(old_note.data["updated"])

	updated_note =
	Map.put(updated_note, "updated", DateTime.to_iso8601(DateTime.add(update_time, -5)))

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)

	new_note = Pleroma.Object.get_by_id(object_id)
	assert old_note.data == new_note.data
	end

	test "it updates using object_data", %{
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	updated_note = Map.put(updated_note, "summary", "mew mew")
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	new_note = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "mew mew", "content" => "edited content"} = new_note.data
	end

	test "it records the original note in formerRepresentations", %{
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary", "content" => "edited content"} = new_note

	assert [Map.drop(note.data, ["id", "formerRepresentations"])] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 1
	end

	test "it puts the original note at the front of formerRepresentations", %{
	user: user,
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: first_edit} = Pleroma.Object.get_by_id(object_id)

	second_updated_note =
	note.data
	\|> Map.put("summary", "edited summary 2")
	\|> Map.put("content", "edited content 2")
	\|> Map.put(
	"updated",
	first_edit["updated"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> DateTime.add(10)
	\|> DateTime.to_iso8601()
	)

	{:ok, second_update_data, []} = Builder.update(user, second_updated_note)
	{:ok, update, _meta} = ActivityPub.persist(second_update_data, local: true)
	{:ok, _, _} = SideEffects.handle(update, object_data: second_updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary 2", "content" => "edited content 2"} = new_note

	original_version = Map.drop(note.data, ["id", "formerRepresentations"])
	first_edit = Map.drop(first_edit, ["id", "formerRepresentations"])

	assert [first_edit, original_version] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 2
	end

	test "it does not prepend to formerRepresentations if no actual changes are made", %{
	note: note,
	object_id: object_id,
	update: update,
	updated_note: updated_note
	} do
	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: first_edit} = Pleroma.Object.get_by_id(object_id)

	updated_note =
	updated_note
	\|> Map.put(
	"updated",
	first_edit["updated"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> DateTime.add(10)
	\|> DateTime.to_iso8601()
	)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_note)
	%{data: new_note} = Pleroma.Object.get_by_id(object_id)
	assert %{"summary" => "edited summary", "content" => "edited content"} = new_note

	original_version = Map.drop(note.data, ["id", "formerRepresentations"])

	assert [original_version] ==
	new_note["formerRepresentations"]["orderedItems"]

	assert new_note["formerRepresentations"]["totalItems"] == 1
	end
	end

	describe "update questions" do
	setup do
	user = insert(:user)

	question =
	insert(:question,
	user: user,
	data: %{"published" => Pleroma.Web.ActivityPub.Utils.make_date()}
	)

	%{user: user, data: question.data, id: question.id}
	end

	test "allows updating choice count without generating edit history", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)
	\|> Map.put("updated", Pleroma.Web.ActivityPub.Utils.make_date())

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end

	test "allows updating choice count without updated field", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end

	test "allows updating choice count with updated field same as the creation date", %{
	user: user,
	data: data,
	id: id
	} do
	new_choices =
	data["oneOf"]
	\|> Enum.map(fn choice -> put_in(choice, ["replies", "totalItems"], 5) end)

	updated_question =
	data
	\|> Map.put("oneOf", new_choices)
	\|> Map.put("updated", data["published"])

	{:ok, update_data, []} = Builder.update(user, updated_question)
	{:ok, update, _meta} = ActivityPub.persist(update_data, local: true)

	{:ok, _, _} = SideEffects.handle(update, object_data: updated_question)

	%{data: new_question} = Pleroma.Object.get_by_id(id)

	assert [%{"replies" => %{"totalItems" => 5}}, %{"replies" => %{"totalItems" => 5}}] =
	new_question["oneOf"]

	refute Map.has_key?(new_question, "formerRepresentations")
	end
	end

	describe "EmojiReact objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
	{:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)

	%{emoji_react: emoji_react, user: user, poster: poster}
	end

	test "adds the reaction to the object", %{emoji_react: emoji_react, user: user} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	object = Object.get_by_ap_id(emoji_react.data["object"])

	assert object.data["reaction_count"] == 1
	assert ["👌", [user.ap_id], nil] in object.data["reactions"]
	end

	test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: emoji_react.id)
	end
	end

	describe "Question objects" do
	setup do
	user = insert(:user)
	question = build(:question, user: user)
	question_activity = build(:question_activity, question: question)
	activity_data = Map.put(question_activity.data, "object", question.data["id"])
	meta = [object_data: question.data, local: false]

	{:ok, activity, meta} = ActivityPub.persist(activity_data, meta)

	%{activity: activity, meta: meta}
	end

	test "enqueues the poll end", %{activity: activity, meta: meta} do
	{:ok, activity, meta} = SideEffects.handle(activity, meta)

	assert_enqueued(
	worker: Pleroma.Workers.PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: NaiveDateTime.from_iso8601!(meta[:object_data]["closed"])
	)
	end
	end

	describe "delete users with confirmation pending" do
	setup do
	user = insert(:user, is_confirmed: false)
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
	{:ok, delete: delete_user, user: user}
	end

	test "when activation is required", %{delete: delete, user: user} do
	clear_config([:instance, :account_activation_required], true)
	{:ok, _, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	refute User.get_cached_by_id(user.id)
	end
	end

	describe "Undo objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, like} = CommonAPI.favorite(post.id, user)
	{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
	{:ok, announce} = CommonAPI.repeat(post.id, user)
	{:ok, block} = CommonAPI.block(poster, user)

	{:ok, undo_data, _meta} = Builder.undo(user, like)
	{:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, reaction)
	{:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, announce)
	{:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, block)
	{:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	%{
	like_undo: like_undo,
	post: post,
	like: like,
	reaction_undo: reaction_undo,
	reaction: reaction,
	announce_undo: announce_undo,
	announce: announce,
	block_undo: block_undo,
	block: block,
	poster: poster,
	user: user
	}
	end

	test "deletes the original block", %{
	block_undo: block_undo,
	block: block
	} do
	{:ok, _block_undo, _meta} = SideEffects.handle(block_undo)

	refute Activity.get_by_id(block.id)
	end

	test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
	blocker = User.get_by_ap_id(block.data["actor"])
	blocked = User.get_by_ap_id(block.data["object"])

	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute User.blocks?(blocker, blocked)
	end

	test "an announce undo removes the announce from the object", %{
	announce_undo: announce_undo,
	post: post
	} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["announcement_count"] == 0
	assert object.data["announcements"] == []
	end

	test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
	refute Activity.get_by_id(announce.id)
	end

	test "a reaction undo removes the reaction from the object", %{
	reaction_undo: reaction_undo,
	post: post
	} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["reaction_count"] == 0
	assert object.data["reactions"] == []
	end

	test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
	refute Activity.get_by_id(reaction.id)
	end

	test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["like_count"] == 0
	assert object.data["likes"] == []
	end

	test "deletes the original like", %{like_undo: like_undo, like: like} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)
	refute Activity.get_by_id(like.id)
	end
	end

	describe "like objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, like_data, _meta} = Builder.like(user, post.object)
	{:ok, like, _meta} = ActivityPub.persist(like_data, local: true)

	%{like: like, user: user, poster: poster}
	end

	test "add the like to the original object", %{like: like, user: user} do
	{:ok, like, _} = SideEffects.handle(like)
	object = Object.get_by_ap_id(like.data["object"])
	assert object.data["like_count"] == 1
	assert user.ap_id in object.data["likes"]
	end

	test "creates a notification", %{like: like, poster: poster} do
	{:ok, like, _} = SideEffects.handle(like)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
	end
	end

	describe "creation of ChatMessages" do
	test "notifies the recipient" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert Repo.get_by(Notification, user_id: recipient.id, activity_id: create_activity.id)
	end

	test "it streams the created ChatMessage" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert [_, _] = meta[:streamables]
	end

	test "it creates a Chat and MessageReferences for the local users and bumps the unread count, except for the author" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, _create_activity, meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# The notification gets created
	assert [notification] = meta[:notifications]
	assert notification.activity_id == create_activity.id

	# But it is not sent out
	refute called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	refute called(Pleroma.Web.Push.send(notification))

	# Same for the user chat stream
	assert [{topics, _}, _] = meta[:streamables]
	assert topics == ["user", "user:pleroma_chat"]
	refute called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

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

	[cm_ref] = MessageReference.for_chat_query(chat) \|> Repo.all()

	assert cm_ref.object.data["content"] == "hey"
	assert cm_ref.unread == false

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

	[cm_ref] = MessageReference.for_chat_query(chat) \|> Repo.all()

	assert cm_ref.object.data["content"] == "hey"
	assert cm_ref.unread == true
	end
	end

	test "it creates a Chat for the local users and bumps the unread count" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# An object is created
	assert Object.get_by_ap_id(chat_message_data["id"])

	# The remote user won't get a chat
	chat = Chat.get(author.id, recipient.ap_id)
	refute chat

	# The local user will get a chat
	chat = Chat.get(recipient.id, author.ap_id)
	assert chat

	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# Both users are local and get the chat
	chat = Chat.get(author.id, recipient.ap_id)
	assert chat

	chat = Chat.get(recipient.id, author.ap_id)
	assert chat
	end
	end

	describe "creation of Notes" do
	setup do
	author = insert(:user, local: true)
	mentioned = insert(:user, local: true)

	{:ok, draft} = ActivityDraft.create(author, %{status: "hey @#{mentioned.nickname}"})
	{:ok, note_data, _meta} = Builder.note(draft)

	note_data =
	note_data
	\|> Map.put("id", Utils.generate_object_id())
	\|> Map.put("published", Utils.make_date())

	{:ok, create_data, _meta} = Builder.create(author, note_data["id"], note_data["to"])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_data, local: true)

	%{
	author: author,
	mentioned: mentioned,
	note_data: note_data,
	create_activity: create_activity
	}
	end

	test "it streams out the activity only after the transaction", %{
	create_activity: create_activity,
	note_data: note_data,
	mentioned: mentioned
	} do
	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, create_activity, meta} =
	SideEffects.handle(create_activity, local: true, object_data: note_data)

	verify!()

	assert [notification] = meta[:notifications]
	assert notification.user_id == mentioned.id

	ActivityPubMock
	\|> expect(:stream_out, fn ^create_activity -> nil end)

	SideEffects.handle_after_transaction(meta)
	end
	+
	+ test "it creates a conversation for direct messages and queues the participations for streaming",
	+ %{author: author, mentioned: mentioned} do
	+ {:ok, draft} =
	+ ActivityDraft.create(author, %{
	+ status: "hey @#{mentioned.nickname}",
	+ visibility: "direct"
	+ })
	+
	+ {:ok, note_data, _meta} = Builder.note(draft)
	+
	+ note_data =
	+ note_data
	+ \|> Map.put("id", Utils.generate_object_id())
	+ \|> Map.put("published", Utils.make_date())
	+
	+ {:ok, create_data, _meta} = Builder.create(author, note_data["id"], note_data["to"])
	+ {:ok, create_activity, _meta} = ActivityPub.persist(create_data, local: true)
	+
	+ {:ok, _create_activity, meta} =
	+ SideEffects.handle(create_activity, local: true, object_data: note_data)
	+
	+ assert [%Participation{read: true}] = Participation.for_user(author)
	+ assert [%Participation{read: false}] = Participation.for_user(mentioned)
	+
	+ assert [{"participation", participations}] = meta[:streamables]
	+
	+ assert Enum.map(participations, & &1.user.id) \|> Enum.sort() ==
	+ Enum.sort([author.id, mentioned.id])
	+ end
	+
	+ test "it does not create a conversation for public posts", %{
	+ create_activity: create_activity,
	+ note_data: note_data,
	+ author: author
	+ } do
	+ {:ok, _create_activity, meta} =
	+ SideEffects.handle(create_activity, local: true, object_data: note_data)
	+
	+ assert [] == Participation.for_user(author)
	+ refute meta[:streamables]
	+ end
	end

	describe "announce objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, private_post} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, announce_data, _meta} = Builder.announce(user, post.object, visibility: "public")

	{:ok, private_announce_data, _meta} =
	Builder.announce(user, private_post.object, visibility: "private")

	{:ok, relay_announce_data, _meta} =
	Builder.announce(Pleroma.Web.ActivityPub.Relay.get_actor(), post.object,
	visibility: "public"
	)

	{:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)
	{:ok, private_announce, _meta} = ActivityPub.persist(private_announce_data, local: true)
	{:ok, relay_announce, _meta} = ActivityPub.persist(relay_announce_data, local: true)

	%{
	announce: announce,
	user: user,
	poster: poster,
	private_announce: private_announce,
	relay_announce: relay_announce
	}
	end

	test "adds the announce to the original object", %{announce: announce, user: user} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == 1
	assert user.ap_id in object.data["announcements"]
	end

	test "does not add the announce to the original object if the actor is a service actor", %{
	relay_announce: announce
	} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == nil
	end

	test "creates a notification", %{announce: announce, poster: poster} do
	{:ok, announce, _} = SideEffects.handle(announce)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: announce.id)
	end

	test "streams out the announce only after the transaction", %{announce: announce} do
	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, announce, meta} = SideEffects.handle(announce)

	verify!()

	ActivityPubMock
	\|> expect(:stream_out, fn ^announce -> nil end)

	SideEffects.handle_after_transaction(meta)
	end

	test "does not stream out announces by internal actors", %{poster: poster} do
	internal_actor = Pleroma.Web.ActivityPub.InternalFetchActor.get_actor()
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, announce_data, _meta} =
	Builder.announce(internal_actor, post.object, visibility: "public")

	{:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)

	ActivityPubMock
	\|> expect(:stream_out, 0, fn _ -> nil end)

	{:ok, _announce, meta} = SideEffects.handle(announce)
	SideEffects.handle_after_transaction(meta)
	end
	end

	describe "removing a follower" do
	setup do
	user = insert(:user)
	followed = insert(:user)

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

	{:ok, reject_data, []} = Builder.reject(followed, follow_activity)
	{:ok, reject, _meta} = ActivityPub.persist(reject_data, local: true)

	%{user: user, followed: followed, reject: reject}
	end

	test "", %{user: user, followed: followed, reject: reject} do
	assert User.following?(user, followed)
	assert Pleroma.FollowingRelationship.get(user, followed)

	{:ok, _, _} = SideEffects.handle(reject)

	refute User.following?(user, followed)
	refute Pleroma.FollowingRelationship.get(user, followed)
	assert User.get_follow_state(user, followed) == nil
	assert User.get_follow_state(user, followed, nil) == nil
	end
	end

	describe "removing a follower from remote" do
	setup do
	user = insert(:user)
	followed = insert(:user, local: false)

	# Mock a local-to-remote follow
	{:ok, follow_data, []} = Builder.follow(user, followed)

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

	{:ok, follow, _meta} = ActivityPub.persist(follow_data, local: true)
	{:ok, _, _} = SideEffects.handle(follow)

	# Mock a remote-to-local accept
	{:ok, accept_data, _} = Builder.accept(followed, follow)
	{:ok, accept, _} = ActivityPub.persist(accept_data, local: false)
	{:ok, _, _} = SideEffects.handle(accept)

	# Mock a remote-to-local reject
	{:ok, reject_data, []} = Builder.reject(followed, follow)
	{:ok, reject, _meta} = ActivityPub.persist(reject_data, local: false)

	%{user: user, followed: followed, reject: reject}
	end

	test "", %{user: user, followed: followed, reject: reject} do
	assert User.following?(user, followed)
	assert Pleroma.FollowingRelationship.get(user, followed)

	{:ok, _, _} = SideEffects.handle(reject)

	refute User.following?(user, followed)
	refute Pleroma.FollowingRelationship.get(user, followed)

	assert Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, followed).data["state"] ==
	"reject"

	assert User.get_follow_state(user, followed) == nil
	assert User.get_follow_state(user, followed, nil) == nil
	end
	end

	describe "Group actors" do
	setup do
	poster =
	insert(:user,
	local: false,
	nickname: "poster@example.com",
	ap_id: "https://example.com/users/poster"
	)

	group = insert(:user, actor_type: "Group")

	make_create = fn mentioned_users ->
	mentions = mentioned_users \|> Enum.map(fn u -> "@#{u.nickname}" end) \|> Enum.join(" ")
	{:ok, draft} = ActivityDraft.create(poster, %{status: "#{mentions} hey"})

	create_activity_data =
	Utils.make_create_data(draft.changes \|> Map.put(:published, nil), %{})
	\|> put_in(["object", "id"], "https://example.com/object")
	\|> put_in(["id"], "https://example.com/activity")

	assert Enum.all?(mentioned_users, fn u -> u.ap_id in create_activity_data["to"] end)

	create_activity_data
	end

	%{poster: poster, group: group, make_create: make_create}
	end

	test "group should boost it", %{make_create: make_create, group: group} do
	create_activity_data = make_create.([group])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity,
	local: false,
	object_data: create_activity_data["object"]
	)

	object = Object.normalize(create_activity, fetch: false)
	assert [announce] = get_announces_of_object(object)
	assert announce.actor == group.ap_id
	end

	test "remote group should not boost it", %{make_create: make_create, group: group} do
	remote_group =
	insert(:user, actor_type: "Group", local: false, nickname: "remotegroup@example.com")

	create_activity_data = make_create.([group, remote_group])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity,
	local: false,
	object_data: create_activity_data["object"]
	)

	object = Object.normalize(create_activity, fetch: false)
	assert [announce] = get_announces_of_object(object)
	assert announce.actor == group.ap_id
	end

	test "group should not boost it if group is blocking poster", %{
	make_create: make_create,
	group: group,
	poster: poster
	} do
	{:ok, _} = CommonAPI.block(poster, group)
	create_activity_data = make_create.([group])
	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity,
	local: false,
	object_data: create_activity_data["object"]
	)

	object = Object.normalize(create_activity, fetch: false)
	assert [] = get_announces_of_object(object)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	index 793293abd..e071af0c5 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
	@@ -1,822 +1,853 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	+ alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	+ alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory

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

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

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

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

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

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

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

	assert "test" in Object.tags(object)
	assert Object.hashtags(object) == ["test"]
	end

	+ test "it creates a conversation and participations for incoming direct messages" do
	+ recipient = insert(:user)
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-post-activity.json")
	+ \|> Jason.decode!()
	+
	+ object =
	+ data["object"]
	+ \|> Map.put("to", [recipient.ap_id])
	+ \|> Map.put("cc", [])
	+
	+ data =
	+ data
	+ \|> Map.put("to", [recipient.ap_id])
	+ \|> Map.put("cc", [])
	+ \|> Map.put("object", object)
	+
	+ {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(data)
	+
	+ assert [%Participation{read: false, conversation: conversation}] =
	+ recipient \|> Participation.for_user() \|> Repo.preload(:conversation)
	+
	+ assert conversation.ap_id == Object.normalize(activity, fetch: false).data["context"]
	+
	+ sender = User.get_cached_by_ap_id(data["actor"])
	+ assert [%Participation{read: true}] = Participation.for_user(sender)
	+ end
	+
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

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

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

	assert activity == returned_activity
	end

	test "it fetches reply-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://mstdn.io/users/mayuutann/statuses/99568293732299394")

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

	assert %Activity{} =
	Activity.get_create_by_object_ap_id(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)

	assert returned_object.data["inReplyTo"] ==
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	end

	test "it does not fetch reply-to activities beyond max replies depth limit" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

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

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

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

	returned_object = Object.normalize(returned_activity, fetch: false)

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

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

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

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

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

	assert {:ok, _returned_activity} = Transmogrifier.handle_incoming(data)
	end

	test "it does not work for deactivated users" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	insert(:user, ap_id: data["actor"], is_active: false)

	assert {:error, _} = Transmogrifier.handle_incoming(data)
	end

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

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

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

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

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

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

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

	object_data = Object.normalize(data["object"], fetch: false).data

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

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

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

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

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

	assert object_data["sensitive"] == true

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

	assert user.note_count == 1
	end

	test "it works for incoming notices without the sensitive property but an nsfw hashtag" do
	data = File.read!("test/fixtures/mastodon-post-activity-nsfw.json") \|> Jason.decode!()

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

	object_data = Object.normalize(data["object"], fetch: false).data

	assert object_data["sensitive"] == true
	end

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

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

	assert match?(
	%{
	"href" => "http://localtesting.pleroma.lol/users/lain",
	"name" => "@lain@localtesting.pleroma.lol",
	"type" => "Mention"
	},
	Enum.at(object.data["tag"], 0)
	)

	assert match?(
	%{
	"href" => "http://mastodon.example.org/tags/moo",
	"name" => "#moo",
	"type" => "Hashtag"
	},
	Enum.at(object.data["tag"], 1)
	)

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

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

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

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

	test "it only uses contentMap if content is not present" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Hi",
	"contentMap" => %{
	"de" => "Hallo",
	"uk" => "Привіт"
	},
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

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

	assert object.data["content"] == "Hi"
	end

	test "it works for incoming notices with a nil contentMap (firefish)" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json")
	\|> Jason.decode!()
	\|> Map.put("contentMap", nil)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute is_nil(data["cc"])
	end

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

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

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

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

	object = Object.normalize(activity)

	assert object.data["likes"] == []
	end

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

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

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

	test "it correctly processes messages with non-array to field" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("to", "https://www.w3.org/ns/activitystreams#Public")
	\|> put_in(["object", "to"], "https://www.w3.org/ns/activitystreams#Public")

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

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

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

	test "it correctly processes messages with non-array cc field" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("cc", "http://mastodon.example.org/users/admin/followers")
	\|> put_in(["object", "cc"], "http://mastodon.example.org/users/admin/followers")

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

	assert ["http://mastodon.example.org/users/admin/followers"] == activity.data["cc"]
	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with weirdness in address fields" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("cc", ["http://mastodon.example.org/users/admin/followers", ["¿"]])
	\|> put_in(["object", "cc"], ["http://mastodon.example.org/users/admin/followers", ["¿"]])

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

	assert ["http://mastodon.example.org/users/admin/followers"] == activity.data["cc"]
	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end
	end

	describe "`handle_incoming/2`, Mastodon format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	items = get_in(data, ["object", "replies", "first", "items"])
	assert length(items) > 0

	%{data: data, items: items}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	data: data,
	items: items
	} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 10)

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

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

	assert object.data["replies"] == items

	for id <- items do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{data: data} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

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

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "`handle_incoming/2`, Pleroma format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	replies = %{
	"type" => "Collection",
	"items" => [Utils.generate_object_id(), Utils.generate_object_id()]
	}

	activity =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["object", "replies"], replies)

	%{activity: activity}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	activity: activity
	} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 1)

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

	for id <- object.data["replies"] do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{activity: activity} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

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

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

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

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

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

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

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

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

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

	describe "fix_in_reply_to/2" do
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

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

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

	test "returns object with inReplyTo when denied incoming reply", %{data: data} do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

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

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

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

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

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

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

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

	test "returns modified object when allowed incoming reply", %{data: data} do
	object_with_reply =
	Map.put(
	data["object"],
	"inReplyTo",
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)

	clear_config([:instance, :federation_incoming_replies_max_depth], 5)
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)

	assert modified_object["inReplyTo"] ==
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"

	assert modified_object["context"] ==
	"tag:shitposter.club,2018-02-22:objectType=thread:nonce=e5a7c72d60a9c0e4"
	end
	end

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

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

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

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

	test "returns object with emoji when object contains list tags" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => [
	%{
	"type" => "Emoji",
	"name" => ":bib:",
	"icon" => %{"url" => "https://example.com/test"}
	},
	%{"type" => "Hashtag"}
	]
	}) == %{
	"emoji" => %{"bib" => "https://example.com/test"},
	"tag" => [
	%{
	"icon" => %{"url" => "https://example.com/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" => "https://example.com/test"}
	}
	}) == %{
	"emoji" => %{"bib" => "https://example.com/test"},
	"tag" => %{
	"icon" => %{"url" => "https://example.com/test"},
	"name" => ":bib:",
	"type" => "Emoji"
	}
	}
	end
	end

	describe "fix_tag/1" do
	test "ignores malformed Hashtag names and tag entries" do
	tag = %{"type" => "Hashtag", "name" => 123}

	assert Transmogrifier.fix_tag(%{"tag" => [tag, "malformed"]}) == %{
	"tag" => [tag, "malformed"]
	}
	end
	end

	describe "set_replies/1" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 2)

	test "still provides reply collection id even if activity doesn't have replies yet" do
	data = Jason.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	object = data["object"] \|> Map.delete("replies")
	modified = Transmogrifier.set_replies(object)

	refute object["replies"]
	assert modified["replies"]
	assert match?(%{"id" => "http" <> _, "totalItems" => 0}, modified["replies"])
	# first page should be omitted if there are no entries anyway
	refute modified["replies"]["first"]
	end

	test "sets `replies` collection with a limited number of replies, preferring oldest" do
	[user, another_user] = insert_list(2, :user)

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

	{:ok, %{id: id2} = self_reply1} =
	CommonAPI.post(user, %{status: "self-reply 1", in_reply_to_status_id: id1})

	{:ok, self_reply2} =
	CommonAPI.post(user, %{status: "self-reply 2", in_reply_to_status_id: id1})

	# Assuming to _not_ be present in `replies` due to :note_replies_output_limit is set to 2
	{:ok, _} = CommonAPI.post(user, %{status: "self-reply 3", in_reply_to_status_id: id1})

	{:ok, _} =
	CommonAPI.post(user, %{
	status: "self-reply to self-reply",
	in_reply_to_status_id: id2
	})

	{:ok, _} =
	CommonAPI.post(another_user, %{
	status: "another user's reply",
	in_reply_to_status_id: id1
	})

	object = Object.normalize(activity, fetch: false)
	replies_uris = Enum.map([self_reply1, self_reply2], fn a -> a.object.data["id"] end)

	assert %{"type" => "OrderedCollection", "first" => %{"orderedItems" => ^replies_uris}} =
	Transmogrifier.set_replies(object.data)["replies"]
	end
	end

	test "take_emoji_tags/1" do
	user = insert(:user, %{emoji: %{"firefox" => "https://example.org/firefox.png"}})

	assert Transmogrifier.take_emoji_tags(user) == [
	%{
	"icon" => %{"type" => "Image", "url" => "https://example.org/firefox.png"},
	"id" => "https://example.org/firefox.png",
	"name" => ":firefox:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	end

	test "the standalone note uses its own ID when context is missing" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")

	activity =
	"test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	{:ok, %Activity{} = modified} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(modified, fetch: false)

	assert object.data["context"] == object.data["id"]
	assert modified.data["context"] == object.data["id"]
	end

	test "the reply note uses its parent's ID when context is missing and reply is unreachable" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")

	activity =
	"test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	object =
	activity["object"]
	\|> Map.put("inReplyTo", "https://404.site/object/went-to-buy-milk")

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

	{:ok, %Activity{} = modified} = Transmogrifier.handle_incoming(activity)
	object = Object.normalize(modified, fetch: false)

	assert object.data["context"] == object.data["inReplyTo"]
	assert modified.data["context"] == object.data["inReplyTo"]
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 7:22 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1769104
Default Alt Text: (92 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions