No OneTemporary
Actions

Size

47 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index df926829c..0dcc7be4d 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,175 +1,182 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	+ alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	@spec validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	def validate(object, meta)

	def validate(%{"type" => "Follow"} = object, meta) do
	with {:ok, object} <-
	object
	\|> FollowValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Block"} = block_activity, meta) do
	with {:ok, block_activity} <-
	block_activity
	\|> BlockValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	block_activity = stringify_keys(block_activity)
	outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])

	meta =
	if !outgoing_blocks do
	Keyword.put(meta, :do_not_federate, true)
	else
	meta
	end

	{:ok, block_activity, meta}
	end
	end

	def validate(%{"type" => "Update"} = update_activity, meta) do
	with {:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	end
	end

	def validate(%{"type" => "Undo"} = object, meta) do
	with {:ok, object} <-
	object
	\|> UndoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	+ undone_object = Activity.get_by_ap_id(object["object"])
	+
	+ meta =
	+ meta
	+ \|> Keyword.put(:object_data, undone_object.data)
	+
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Delete"} = object, meta) do
	with cng <- DeleteValidator.cast_and_validate(object),
	do_not_federate <- DeleteValidator.do_not_federate?(cng),
	{:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
	object = stringify_keys(object)
	meta = Keyword.put(meta, :do_not_federate, do_not_federate)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Like"} = object, meta) do
	with {:ok, object} <-
	object
	\|> LikeValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object} <-
	object
	\|> ChatMessageValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "EmojiReact"} = object, meta) do
	with {:ok, object} <-
	object
	\|> EmojiReactValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object \|> Map.from_struct())
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Create", "object" => object} = create_activity, meta) do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateChatMessageValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => "Announce"} = object, meta) do
	with {:ok, object} <-
	object
	\|> AnnounceValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object \|> Map.from_struct())
	{:ok, object, meta}
	end
	end

	def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	ChatMessageValidator.cast_and_apply(object)
	end

	def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	def stringify_keys(%{__struct__: _} = object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

	def stringify_keys(object) when is_list(object) do
	object
	\|> Enum.map(&stringify_keys/1)
	end

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	with {:ok, actor} <- ObjectValidators.ObjectID.cast(object["actor"]) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], true)
	:ok
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/pipeline.ex b/lib/pleroma/web/activity_pub/pipeline.ex
	index 50d9016e6..36e325c37 100644
	--- a/lib/pleroma/web/activity_pub/pipeline.ex
	+++ b/lib/pleroma/web/activity_pub/pipeline.ex
	@@ -1,71 +1,71 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Pipeline do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.Federator

	@spec common_pipeline(map(), keyword()) ::
	{:ok, Activity.t() \| Object.t(), keyword()} \| {:error, any()}
	def common_pipeline(object, meta) do
	case Repo.transaction(fn -> do_common_pipeline(object, meta) end) do
	{:ok, {:ok, activity, meta}} ->
	SideEffects.handle_after_transaction(meta)
	{:ok, activity, meta}

	{:ok, value} ->
	value

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

	def do_common_pipeline(object, meta) do
	with {_, {:ok, validated_object, meta}} <-
	{:validate_object, ObjectValidator.validate(object, meta)},
	{_, {:ok, mrfd_object}} <- {:mrf_object, MRF.filter(validated_object)},
	{_, {:ok, activity, meta}} <-
	{:persist_object, ActivityPub.persist(mrfd_object, meta)},
	{_, {:ok, activity, meta}} <-
	{:execute_side_effects, SideEffects.handle(activity, meta)},
	{_, {:ok, _}} <- {:federation, maybe_federate(activity, meta)} do
	{:ok, activity, meta}
	else
	{:mrf_object, {:reject, _}} -> {:ok, nil, meta}
	e -> {:error, e}
	end
	end

	defp maybe_federate(%Object{}, _), do: {:ok, :not_federated}

	defp maybe_federate(%Activity{} = activity, meta) do
	with {:ok, local} <- Keyword.fetch(meta, :local) do
	do_not_federate = meta[:do_not_federate] \|\| !Config.get([:instance, :federating])

	if !do_not_federate && local do
	activity =
	- if object = Keyword.get(meta, :embedded_object) do
	+ if object = Keyword.get(meta, :object_data) do
	%{activity \| data: Map.put(activity.data, "object", object)}
	else
	activity
	end

	Federator.publish(activity)
	{:ok, :federated}
	else
	{:ok, :not_federated}
	end
	else
	_e -> {:error, :badarg}
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index 33bee1576..1d2c296a5 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,366 +1,362 @@
	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.Activity.Ir.Topics
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	def handle(object, meta \\ [])

	# Tasks this handle
	# - Follows if possible
	# - Sends a notification
	# - Generates accept or reject if appropriate
	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.locked do
	Utils.update_follow_state_for_all(object, "accept")
	FollowingRelationship.update(follower, followed, :follow_accept)
	User.update_follower_count(followed)
	User.update_following_count(follower)

	%{
	to: [following_user],
	actor: followed,
	object: follow_id,
	local: true
	}
	\|> ActivityPub.accept()
	end
	else
	{:following, {:error, _}, follower, followed} ->
	Utils.update_follow_state_for_all(object, "reject")
	FollowingRelationship.update(follower, followed, :follow_reject)

	if followed.local do
	%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_id,
	local: true
	}
	\|> ActivityPub.reject()
	end

	_ ->
	nil
	end

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

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

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Update the user
	#
	# For a local user, we also get a changeset with the full information, so we
	# can update non-federating, non-activitypub settings as well.
	def handle(%{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

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	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)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Set up notifications
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, _object, meta} <- handle_object_creation(meta[:object_data], meta) do
	{:ok, notifications} = Notification.create_notifications(activity, do_send: false)

	meta =
	meta
	\|> add_notifications(notifications)

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

	# Tasks this handles:
	# - Add announce to object
	# - Set up notification
	# - Stream out the announce
	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)

	if !User.is_internal_user?(user) do
	Notification.create_notifications(object)

	object
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(object)
	end

	{:ok, object, meta}
	end

	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
	- meta =
	- meta
	- \|> Keyword.put(:embedded_object, undone_object.data)
	-
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	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)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Set up notification
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, false) \|\| User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	with {:ok, deleted_object, activity} <- Object.delete(deleted_object),
	%User{} = user <- User.get_cached_by_ap_id(deleted_object.data["actor"]) do
	User.remove_pinnned_activity(user, activity)

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

	MessageReference.delete_for_object(deleted_object)

	ActivityPub.stream_out(object)
	ActivityPub.stream_out_participations(deleted_object, user)
	:ok
	end

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

	if result == :ok do
	Notification.create_notifications(object)
	{:ok, object, meta}
	else
	{:error, result}
	end
	end

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

	def handle_object_creation(%{"type" => "ChatMessage"} = object, 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.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)

	{
	["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

	# Nothing to do
	def handle_object_creation(object) do
	{:ok, object}
	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(Object.t()) :: :ok \| {:error, Ecto.Changeset.t()}
	defp delete_object(object) do
	with {:ok, _} <- Repo.delete(object), do: :ok
	end

	defp send_notifications(meta) do
	Keyword.get(meta, :notifications, [])
	\|> Enum.each(fn notification ->
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end)

	meta
	end

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

	meta
	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

	def handle_after_transaction(meta) do
	meta
	\|> send_notifications()
	\|> send_streamables()
	end
	end
	diff --git a/test/web/activity_pub/pipeline_test.exs b/test/web/activity_pub/pipeline_test.exs
	index 202b5fe61..f2a231eaf 100644
	--- a/test/web/activity_pub/pipeline_test.exs
	+++ b/test/web/activity_pub/pipeline_test.exs
	@@ -1,179 +1,179 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.PipelineTest do
	use Pleroma.DataCase

	import Mock
	import Pleroma.Factory

	describe "common_pipeline/2" do
	setup do
	clear_config([:instance, :federating], true)
	:ok
	end

	- test "when given an `embedded_object` in meta, Federation will receive a the original activity with the `object` field set to this embedded object" do
	+ test "when given an `object_data` in meta, Federation will receive a the original activity with the `object` field set to this embedded object" do
	activity = insert(:note_activity)
	object = %{"id" => "1", "type" => "Love"}
	- meta = [local: true, embedded_object: object]
	+ meta = [local: true, object_data: object]

	activity_with_object = %{activity \| data: Map.put(activity.data, "object", object)}

	with_mocks([
	{Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	{
	Pleroma.Web.ActivityPub.MRF,
	[],
	[filter: fn o -> {:ok, o} end]
	},
	{
	Pleroma.Web.ActivityPub.ActivityPub,
	[],
	[persist: fn o, m -> {:ok, o, m} end]
	},
	{
	Pleroma.Web.ActivityPub.SideEffects,
	[],
	[
	handle: fn o, m -> {:ok, o, m} end,
	handle_after_transaction: fn m -> m end
	]
	},
	{
	Pleroma.Web.Federator,
	[],
	[publish: fn _o -> :ok end]
	}
	]) do
	assert {:ok, ^activity, ^meta} =
	Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)

	assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.MRF.filter(activity))
	assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	refute called(Pleroma.Web.Federator.publish(activity))
	assert_called(Pleroma.Web.Federator.publish(activity_with_object))
	end
	end

	test "it goes through validation, filtering, persisting, side effects and federation for local activities" do
	activity = insert(:note_activity)
	meta = [local: true]

	with_mocks([
	{Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	{
	Pleroma.Web.ActivityPub.MRF,
	[],
	[filter: fn o -> {:ok, o} end]
	},
	{
	Pleroma.Web.ActivityPub.ActivityPub,
	[],
	[persist: fn o, m -> {:ok, o, m} end]
	},
	{
	Pleroma.Web.ActivityPub.SideEffects,
	[],
	[
	handle: fn o, m -> {:ok, o, m} end,
	handle_after_transaction: fn m -> m end
	]
	},
	{
	Pleroma.Web.Federator,
	[],
	[publish: fn _o -> :ok end]
	}
	]) do
	assert {:ok, ^activity, ^meta} =
	Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)

	assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.MRF.filter(activity))
	assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	assert_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "it goes through validation, filtering, persisting, side effects without federation for remote activities" do
	activity = insert(:note_activity)
	meta = [local: false]

	with_mocks([
	{Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	{
	Pleroma.Web.ActivityPub.MRF,
	[],
	[filter: fn o -> {:ok, o} end]
	},
	{
	Pleroma.Web.ActivityPub.ActivityPub,
	[],
	[persist: fn o, m -> {:ok, o, m} end]
	},
	{
	Pleroma.Web.ActivityPub.SideEffects,
	[],
	[handle: fn o, m -> {:ok, o, m} end, handle_after_transaction: fn m -> m end]
	},
	{
	Pleroma.Web.Federator,
	[],
	[]
	}
	]) do
	assert {:ok, ^activity, ^meta} =
	Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)

	assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.MRF.filter(activity))
	assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	end
	end

	test "it goes through validation, filtering, persisting, side effects without federation for local activities if federation is deactivated" do
	clear_config([:instance, :federating], false)

	activity = insert(:note_activity)
	meta = [local: true]

	with_mocks([
	{Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	{
	Pleroma.Web.ActivityPub.MRF,
	[],
	[filter: fn o -> {:ok, o} end]
	},
	{
	Pleroma.Web.ActivityPub.ActivityPub,
	[],
	[persist: fn o, m -> {:ok, o, m} end]
	},
	{
	Pleroma.Web.ActivityPub.SideEffects,
	[],
	[handle: fn o, m -> {:ok, o, m} end, handle_after_transaction: fn m -> m end]
	},
	{
	Pleroma.Web.Federator,
	[],
	[]
	}
	]) do
	assert {:ok, ^activity, ^meta} =
	Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)

	assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.MRF.filter(activity))
	assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	end
	end
	end
	end
	diff --git a/test/web/activity_pub/side_effects_test.exs b/test/web/activity_pub/side_effects_test.exs
	index d48c235c0..4a08eb7ee 100644
	--- a/test/web/activity_pub/side_effects_test.exs
	+++ b/test/web/activity_pub/side_effects_test.exs
	@@ -1,623 +1,622 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 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.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Mock

	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
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: 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 called(Pleroma.Web.Push.send(notification))
	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 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)
	{:ok, update_data, []} = Builder.update(user, %{"id" => user.ap_id, "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 "delete objects" do
	setup do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, op} = CommonAPI.post(other_user, %{status: "big oof"})
	{:ok, post} = CommonAPI.post(user, %{status: "hey", in_reply_to_id: op})
	{:ok, favorite} = CommonAPI.favorite(user, post.id)
	object = Object.normalize(post)
	{:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)

	%{
	user: user,
	delete: delete,
	post: post,
	object: object,
	delete_user: delete_user,
	op: op,
	favorite: favorite
	}
	end

	test "it handles object deletions", %{
	delete: delete,
	post: post,
	object: object,
	user: user,
	op: op,
	favorite: favorite
	} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
	stream_out: fn _ -> nil end,
	stream_out_participations: fn _, _ -> nil end do
	{:ok, delete, _} = SideEffects.handle(delete)
	user = User.get_cached_by_ap_id(object.data["actor"])

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
	end

	object = Object.get_by_id(object.id)
	assert object.data["type"] == "Tombstone"
	refute Activity.get_by_id(post.id)
	refute Activity.get_by_id(favorite.id)

	user = User.get_by_id(user.id)
	assert user.note_count == 0

	object = Object.normalize(op.data["object"], false)

	assert object.data["repliesCount"] == 0
	end

	test "it handles object deletions when the object itself has been pruned", %{
	delete: delete,
	post: post,
	object: object,
	user: user,
	op: op
	} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
	stream_out: fn _ -> nil end,
	stream_out_participations: fn _, _ -> nil end do
	{:ok, delete, _} = SideEffects.handle(delete)
	user = User.get_cached_by_ap_id(object.data["actor"])

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
	end

	object = Object.get_by_id(object.id)
	assert object.data["type"] == "Tombstone"
	refute Activity.get_by_id(post.id)

	user = User.get_by_id(user.id)
	assert user.note_count == 0

	object = Object.normalize(op.data["object"], false)

	assert object.data["repliesCount"] == 0
	end

	test "it handles user deletions", %{delete_user: delete, user: user} do
	{:ok, _delete, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	assert User.get_cached_by_ap_id(user.ap_id).deactivated
	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]] 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 "delete users with confirmation pending" do
	setup do
	user = insert(:user, confirmation_pending: true)
	{: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 not required", %{delete: delete, user: user} do
	clear_config([:instance, :account_activation_required], false)
	{:ok, _, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	assert User.get_cached_by_id(user.id).deactivated
	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(user, post.id)
	{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
	{:ok, announce} = CommonAPI.repeat(post.id, user)
	{:ok, block} = CommonAPI.block(user, poster)

	{: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, but sets `embedded_object`", %{
	+ test "deletes the original block", %{
	block_undo: block_undo,
	block: block
	} do
	- {:ok, _block_undo, meta} = SideEffects.handle(block_undo)
	+ {:ok, _block_undo, _meta} = SideEffects.handle(block_undo)

	- assert meta[:embedded_object] == block.data
	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 "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, public: true)

	{:ok, private_announce_data, _meta} =
	Builder.announce(user, private_post.object, public: false)

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

	{: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 "it streams out the announce", %{announce: announce} do
	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, announce, _} = SideEffects.handle(announce)

	assert called(
	Pleroma.Web.Streamer.stream(["user", "list", "public", "public:local"], announce)
	)

	assert called(Pleroma.Web.Push.send(:_))
	end
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 6:54 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723825
Default Alt Text: (47 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions