No OneTemporary
Actions

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 1aac62c69..135a5c431 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,183 +1,198 @@
	defmodule Pleroma.Web.ActivityPub.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

	This module encodes our addressing policies and general shape of our objects.
	"""

	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	require Pleroma.Constants

	@spec emoji_react(User.t(), Object.t(), String.t()) :: {:ok, map(), keyword()}
	def emoji_react(actor, object, emoji) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("content", emoji)
	\|> Map.put("type", "EmojiReact")

	{:ok, data, meta}
	end
	end

	@spec undo(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def undo(actor, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Undo",
	"object" => object.data["id"],
	"to" => object.data["to"] \|\| [],
	"cc" => object.data["cc"] \|\| []
	}, []}
	end

	@spec delete(User.t(), String.t()) :: {:ok, map(), keyword()}
	def delete(actor, object_id) do
	object = Object.normalize(object_id, false)

	user = !object && User.get_cached_by_ap_id(object_id)

	to =
	case {object, user} do
	{%Object{}, _} ->
	# We are deleting an object, address everyone who was originally mentioned
	(object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	{_, %User{follower_address: follower_address}} ->
	# We are deleting a user, address the followers of that user
	[follower_address]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object_id,
	"to" => to,
	"type" => "Delete"
	}, []}
	end

	def create(actor, object, recipients) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	"object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}, []}
	end

	def chat_message(actor, recipient, content, opts \\ []) do
	basic = %{
	"id" => Utils.generate_object_id(),
	"actor" => actor.ap_id,
	"type" => "ChatMessage",
	"to" => [recipient],
	"content" => content,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"emoji" => Emoji.Formatter.get_emoji_map(content)
	}

	case opts[:attachment] do
	%Object{data: attachment_data} ->
	{
	:ok,
	Map.put(basic, "attachment", attachment_data),
	[]
	}

	_ ->
	{:ok, basic, []}
	end
	end

	@spec tombstone(String.t(), String.t()) :: {:ok, map(), keyword()}
	def tombstone(actor, id) do
	{:ok,
	%{
	"id" => id,
	"actor" => actor,
	"type" => "Tombstone"
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("type", "Like")

	{:ok, data, meta}
	end
	end

	+ # Retricted to user updates for now, always public
	+ @spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	+ def update(actor, object) do
	+ to = [Pleroma.Constants.as_public(), actor.follower_address]
	+
	+ {:ok,
	+ %{
	+ "id" => Utils.generate_activity_id(),
	+ "type" => "Update",
	+ "actor" => actor.ap_id,
	+ "object" => object,
	+ "to" => to
	+ }, []}
	+ end
	+
	@spec announce(User.t(), Object.t(), keyword()) :: {:ok, map(), keyword()}
	def announce(actor, object, options \\ []) do
	public? = Keyword.get(options, :public, false)

	to =
	cond do
	actor.ap_id == Relay.relay_ap_id() ->
	[actor.follower_address]

	public? ->
	[actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()]

	true ->
	[actor.follower_address, object.data["actor"]]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"context" => object.data["context"],
	"type" => "Announce",
	"published" => Utils.make_date()
	}, []}
	end

	@spec object_action(User.t(), Object.t()) :: {:ok, map(), keyword()}
	defp object_action(actor, object) do
	object_actor = User.get_cached_by_ap_id(object.data["actor"])

	# Address the actor of the object, and our actor's follower collection if the post is public.
	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	# CC everyone who's been addressed in the object, except ourself and the object actor's
	# follower collection
	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index 6a83a2c33..804a9d06e 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,133 +1,144 @@
	# 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.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	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.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" => "Update"} = object, meta) do
	+ with {:ok, object} <-
	+ object
	+ \|> UpdateValidator.cast_and_validate()
	+ \|> Ecto.Changeset.apply_action(:insert) do
	+ object = stringify_keys(object)
	+ {:ok, object, 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)
	{: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/object_validators/update_validator.ex b/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	new file mode 100644
	index 000000000..94d72491b
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	@@ -0,0 +1,43 @@
	+# 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.ObjectValidators.UpdateValidator do
	+ use Ecto.Schema
	+
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	+
	+ import Ecto.Changeset
	+ import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+
	+ @primary_key false
	+
	+ embedded_schema do
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	+ field(:type, :string)
	+ field(:actor, ObjectValidators.ObjectID)
	+ field(:to, ObjectValidators.Recipients, default: [])
	+ field(:cc, ObjectValidators.Recipients, default: [])
	+ # In this case, we save the full object in this activity instead of just a
	+ # reference, so we can always see what was actually changed by this.
	+ field(:object, :map)
	+ end
	+
	+ def cast_data(data) do
	+ %__MODULE__{}
	+ \|> cast(data, __schema__(:fields))
	+ end
	+
	+ def validate_data(cng) do
	+ cng
	+ \|> validate_required([:id, :type, :actor, :to, :cc, :object])
	+ \|> validate_inclusion(:type, ["Update"])
	+ \|> validate_actor_presence()
	+ end
	+
	+ def cast_and_validate(data) do
	+ data
	+ \|> cast_data
	+ \|> validate_data
	+ end
	+end
	diff --git a/test/web/activity_pub/object_validator_test.exs b/test/web/activity_pub/object_validator_test.exs
	index 31224abe0..adb56092d 100644
	--- a/test/web/activity_pub/object_validator_test.exs
	+++ b/test/web/activity_pub/object_validator_test.exs
	@@ -1,625 +1,645 @@
	defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
	use Pleroma.DataCase

	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "attachments" do
	test "works with honkerific attachments" do
	attachment = %{
	"mediaType" => "",
	"name" => "",
	"summary" => "298p3RG7j27tfsZ9RQ.jpg",
	"type" => "Document",
	"url" => "https://honk.tedunangst.com/d/298p3RG7j27tfsZ9RQ.jpg"
	}

	assert {:ok, attachment} =
	AttachmentValidator.cast_and_validate(attachment)
	\|> Ecto.Changeset.apply_action(:insert)

	assert attachment.mediaType == "application/octet-stream"
	end

	test "it turns mastodon attachments into our attachments" do
	attachment = %{
	"url" =>
	"http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
	"type" => "Document",
	"name" => nil,
	"mediaType" => "image/jpeg"
	}

	{:ok, attachment} =
	AttachmentValidator.cast_and_validate(attachment)
	\|> Ecto.Changeset.apply_action(:insert)

	assert [
	%{
	href:
	"http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
	type: "Link",
	mediaType: "image/jpeg"
	}
	] = attachment.url

	assert attachment.mediaType == "image/jpeg"
	end

	test "it handles our own uploads" do
	user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, attachment} =
	attachment.data
	\|> AttachmentValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert)

	assert attachment.mediaType == "image/jpeg"
	end
	end

	describe "chat message create activities" do
	test "it is invalid if the object already exists" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "hey")
	object = Object.normalize(activity, false)

	{:ok, create_data, _} = Builder.create(user, object.data, [recipient.ap_id])

	{:error, cng} = ObjectValidator.validate(create_data, [])

	assert {:object, {"The object to create already exists", []}} in cng.errors
	end

	test "it is invalid if the object data has a different `to` or `actor` field" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, object_data, _} = Builder.chat_message(recipient, user.ap_id, "Hey")

	{:ok, create_data, _} = Builder.create(user, object_data, [recipient.ap_id])

	{:error, cng} = ObjectValidator.validate(create_data, [])

	assert {:to, {"Recipients don't match with object recipients", []}} in cng.errors
	assert {:actor, {"Actor doesn't match with object actor", []}} in cng.errors
	end
	end

	describe "chat messages" do
	setup do
	clear_config([:instance, :remote_limit])
	user = insert(:user)
	recipient = insert(:user, local: false)

	{:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey :firefox:")

	%{user: user, recipient: recipient, valid_chat_message: valid_chat_message}
	end

	test "let's through some basic html", %{user: user, recipient: recipient} do
	{:ok, valid_chat_message, _} =
	Builder.chat_message(
	user,
	recipient.ap_id,
	"hey <a href='https://example.org'>example</a> <script>alert('uguu')</script>"
	)

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["content"] ==
	"hey <a href=\"https://example.org\">example</a> alert('uguu')"
	end

	test "validates for a basic object we build", %{valid_chat_message: valid_chat_message} do
	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert Map.put(valid_chat_message, "attachment", nil) == object
	end

	test "validates for a basic object with an attachment", %{
	valid_chat_message: valid_chat_message,
	user: user
	} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

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

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["attachment"]
	end

	test "validates for a basic object with an attachment in an array", %{
	valid_chat_message: valid_chat_message,
	user: user
	} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	valid_chat_message =
	valid_chat_message
	\|> Map.put("attachment", [attachment.data])

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["attachment"]
	end

	test "validates for a basic object with an attachment but without content", %{
	valid_chat_message: valid_chat_message,
	user: user
	} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	valid_chat_message =
	valid_chat_message
	\|> Map.put("attachment", attachment.data)
	\|> Map.delete("content")

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["attachment"]
	end

	test "does not validate if the message has no content", %{
	valid_chat_message: valid_chat_message
	} do
	contentless =
	valid_chat_message
	\|> Map.delete("content")

	refute match?({:ok, _object, _meta}, ObjectValidator.validate(contentless, []))
	end

	test "does not validate if the message is longer than the remote_limit", %{
	valid_chat_message: valid_chat_message
	} do
	Pleroma.Config.put([:instance, :remote_limit], 2)
	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the recipient is blocking the actor", %{
	valid_chat_message: valid_chat_message,
	user: user,
	recipient: recipient
	} do
	Pleroma.User.block(recipient, user)
	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the actor or the recipient is not in our system", %{
	valid_chat_message: valid_chat_message
	} do
	chat_message =
	valid_chat_message
	\|> Map.put("actor", "https://raymoo.com/raymoo")

	{:error, _} = ObjectValidator.validate(chat_message, [])

	chat_message =
	valid_chat_message
	\|> Map.put("to", ["https://raymoo.com/raymoo"])

	{:error, _} = ObjectValidator.validate(chat_message, [])
	end

	test "does not validate for a message with multiple recipients", %{
	valid_chat_message: valid_chat_message,
	user: user,
	recipient: recipient
	} do
	chat_message =
	valid_chat_message
	\|> Map.put("to", [user.ap_id, recipient.ap_id])

	assert {:error, _} = ObjectValidator.validate(chat_message, [])
	end

	test "does not validate if it doesn't concern local users" do
	user = insert(:user, local: false)
	recipient = insert(:user, local: false)

	{:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
	assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
	end
	end

	describe "EmojiReacts" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})

	object = Pleroma.Object.get_by_ap_id(post_activity.data["object"])

	{:ok, valid_emoji_react, []} = Builder.emoji_react(user, object, "👌")

	%{user: user, post_activity: post_activity, valid_emoji_react: valid_emoji_react}
	end

	test "it validates a valid EmojiReact", %{valid_emoji_react: valid_emoji_react} do
	assert {:ok, _, _} = ObjectValidator.validate(valid_emoji_react, [])
	end

	test "it is not valid without a 'content' field", %{valid_emoji_react: valid_emoji_react} do
	without_content =
	valid_emoji_react
	\|> Map.delete("content")

	{:error, cng} = ObjectValidator.validate(without_content, [])

	refute cng.valid?
	assert {:content, {"can't be blank", [validation: :required]}} in cng.errors
	end

	test "it is not valid with a non-emoji content field", %{valid_emoji_react: valid_emoji_react} do
	without_emoji_content =
	valid_emoji_react
	\|> Map.put("content", "x")

	{:error, cng} = ObjectValidator.validate(without_emoji_content, [])

	refute cng.valid?

	assert {:content, {"must be a single character emoji", []}} in cng.errors
	end
	end

	describe "Undos" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
	{:ok, like} = CommonAPI.favorite(user, post_activity.id)
	{:ok, valid_like_undo, []} = Builder.undo(user, like)

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

	test "it validates a basic like undo", %{valid_like_undo: valid_like_undo} do
	assert {:ok, _, _} = ObjectValidator.validate(valid_like_undo, [])
	end

	test "it does not validate if the actor of the undo is not the actor of the object", %{
	valid_like_undo: valid_like_undo
	} do
	other_user = insert(:user, ap_id: "https://gensokyo.2hu/users/raymoo")

	bad_actor =
	valid_like_undo
	\|> Map.put("actor", other_user.ap_id)

	{:error, cng} = ObjectValidator.validate(bad_actor, [])

	assert {:actor, {"not the same as object actor", []}} in cng.errors
	end

	test "it does not validate if the object is missing", %{valid_like_undo: valid_like_undo} do
	missing_object =
	valid_like_undo
	\|> Map.put("object", "https://gensokyo.2hu/objects/1")

	{:error, cng} = ObjectValidator.validate(missing_object, [])

	assert {:object, {"can't find object", []}} in cng.errors
	assert length(cng.errors) == 1
	end
	end

	describe "deletes" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "cancel me daddy"})

	{:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
	{:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)

	%{user: user, valid_post_delete: valid_post_delete, valid_user_delete: valid_user_delete}
	end

	test "it is valid for a post deletion", %{valid_post_delete: valid_post_delete} do
	{:ok, valid_post_delete, _} = ObjectValidator.validate(valid_post_delete, [])

	assert valid_post_delete["deleted_activity_id"]
	end

	test "it is invalid if the object isn't in a list of certain types", %{
	valid_post_delete: valid_post_delete
	} do
	object = Object.get_by_ap_id(valid_post_delete["object"])

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

	{:ok, _object} =
	object
	\|> Ecto.Changeset.change(%{data: data})
	\|> Object.update_and_set_cache()

	{:error, cng} = ObjectValidator.validate(valid_post_delete, [])
	assert {:object, {"object not in allowed types", []}} in cng.errors
	end

	test "it is valid for a user deletion", %{valid_user_delete: valid_user_delete} do
	assert match?({:ok, _, _}, ObjectValidator.validate(valid_user_delete, []))
	end

	test "it's invalid if the id is missing", %{valid_post_delete: valid_post_delete} do
	no_id =
	valid_post_delete
	\|> Map.delete("id")

	{:error, cng} = ObjectValidator.validate(no_id, [])

	assert {:id, {"can't be blank", [validation: :required]}} in cng.errors
	end

	test "it's invalid if the object doesn't exist", %{valid_post_delete: valid_post_delete} do
	missing_object =
	valid_post_delete
	\|> Map.put("object", "http://does.not/exist")

	{:error, cng} = ObjectValidator.validate(missing_object, [])

	assert {:object, {"can't find object", []}} in cng.errors
	end

	test "it's invalid if the actor of the object and the actor of delete are from different domains",
	%{valid_post_delete: valid_post_delete} do
	valid_user = insert(:user)

	valid_other_actor =
	valid_post_delete
	\|> Map.put("actor", valid_user.ap_id)

	assert match?({:ok, _, _}, ObjectValidator.validate(valid_other_actor, []))

	invalid_other_actor =
	valid_post_delete
	\|> Map.put("actor", "https://gensokyo.2hu/users/raymoo")

	{:error, cng} = ObjectValidator.validate(invalid_other_actor, [])

	assert {:actor, {"is not allowed to delete object", []}} in cng.errors
	end

	test "it's valid if the actor of the object is a local superuser",
	%{valid_post_delete: valid_post_delete} do
	user =
	insert(:user, local: true, is_moderator: true, ap_id: "https://gensokyo.2hu/users/raymoo")

	valid_other_actor =
	valid_post_delete
	\|> Map.put("actor", user.ap_id)

	{:ok, _, meta} = ObjectValidator.validate(valid_other_actor, [])
	assert meta[:do_not_federate]
	end
	end

	describe "likes" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})

	valid_like = %{
	"to" => [user.ap_id],
	"cc" => [],
	"type" => "Like",
	"id" => Utils.generate_activity_id(),
	"object" => post_activity.data["object"],
	"actor" => user.ap_id,
	"context" => "a context"
	}

	%{valid_like: valid_like, user: user, post_activity: post_activity}
	end

	test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
	{:ok, object, _meta} = ObjectValidator.validate(valid_like, [])

	assert "id" in Map.keys(object)
	end

	test "is valid for a valid object", %{valid_like: valid_like} do
	assert LikeValidator.cast_and_validate(valid_like).valid?
	end

	test "sets the 'to' field to the object actor if no recipients are given", %{
	valid_like: valid_like,
	user: user
	} do
	without_recipients =
	valid_like
	\|> Map.delete("to")

	{:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])

	assert object["to"] == [user.ap_id]
	end

	test "sets the context field to the context of the object if no context is given", %{
	valid_like: valid_like,
	post_activity: post_activity
	} do
	without_context =
	valid_like
	\|> Map.delete("context")

	{:ok, object, _meta} = ObjectValidator.validate(without_context, [])

	assert object["context"] == post_activity.data["context"]
	end

	test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
	without_actor = Map.delete(valid_like, "actor")

	refute LikeValidator.cast_and_validate(without_actor).valid?

	with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")

	refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
	end

	test "it errors when the object is missing or not known", %{valid_like: valid_like} do
	without_object = Map.delete(valid_like, "object")

	refute LikeValidator.cast_and_validate(without_object).valid?

	with_invalid_object = Map.put(valid_like, "object", "invalidobject")

	refute LikeValidator.cast_and_validate(with_invalid_object).valid?
	end

	test "it errors when the actor has already like the object", %{
	valid_like: valid_like,
	user: user,
	post_activity: post_activity
	} do
	_like = CommonAPI.favorite(user, post_activity.id)

	refute LikeValidator.cast_and_validate(valid_like).valid?
	end

	test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
	wrapped_like =
	valid_like
	\|> Map.put("actor", %{"id" => valid_like["actor"]})
	\|> Map.put("object", %{"id" => valid_like["object"]})

	validated = LikeValidator.cast_and_validate(wrapped_like)

	assert validated.valid?

	assert {:actor, valid_like["actor"]} in validated.changes
	assert {:object, valid_like["object"]} in validated.changes
	end
	end

	describe "announces" do
	setup do
	user = insert(:user)
	announcer = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})

	object = Object.normalize(post_activity, false)
	{:ok, valid_announce, []} = Builder.announce(announcer, object)

	%{
	valid_announce: valid_announce,
	user: user,
	post_activity: post_activity,
	announcer: announcer
	}
	end

	test "returns ok for a valid announce", %{valid_announce: valid_announce} do
	assert {:ok, _object, _meta} = ObjectValidator.validate(valid_announce, [])
	end

	test "returns an error if the object can't be found", %{valid_announce: valid_announce} do
	without_object =
	valid_announce
	\|> Map.delete("object")

	{:error, cng} = ObjectValidator.validate(without_object, [])

	assert {:object, {"can't be blank", [validation: :required]}} in cng.errors

	nonexisting_object =
	valid_announce
	\|> Map.put("object", "https://gensokyo.2hu/objects/99999999")

	{:error, cng} = ObjectValidator.validate(nonexisting_object, [])

	assert {:object, {"can't find object", []}} in cng.errors
	end

	test "returns an error if we don't have the actor", %{valid_announce: valid_announce} do
	nonexisting_actor =
	valid_announce
	\|> Map.put("actor", "https://gensokyo.2hu/users/raymoo")

	{:error, cng} = ObjectValidator.validate(nonexisting_actor, [])

	assert {:actor, {"can't find user", []}} in cng.errors
	end

	test "returns an error if the actor already announced the object", %{
	valid_announce: valid_announce,
	announcer: announcer,
	post_activity: post_activity
	} do
	_announce = CommonAPI.repeat(post_activity.id, announcer)

	{:error, cng} = ObjectValidator.validate(valid_announce, [])

	assert {:actor, {"already announced this object", []}} in cng.errors
	assert {:object, {"already announced by this actor", []}} in cng.errors
	end

	test "returns an error if the actor can't announce the object", %{
	announcer: announcer,
	user: user
	} do
	{:ok, post_activity} =
	CommonAPI.post(user, %{status: "a secret post", visibility: "private"})

	object = Object.normalize(post_activity, false)

	# Another user can't announce it
	{:ok, announce, []} = Builder.announce(announcer, object, public: false)

	{:error, cng} = ObjectValidator.validate(announce, [])

	assert {:actor, {"can not announce this object", []}} in cng.errors

	# The actor of the object can announce it
	{:ok, announce, []} = Builder.announce(user, object, public: false)

	assert {:ok, _, _} = ObjectValidator.validate(announce, [])

	# The actor of the object can not announce it publicly
	{:ok, announce, []} = Builder.announce(user, object, public: true)

	{:error, cng} = ObjectValidator.validate(announce, [])

	assert {:actor, {"can not announce this object publicly", []}} in cng.errors
	end
	end
	+
	+ describe "updates" do
	+ setup do
	+ user = insert(:user)
	+
	+ object = %{
	+ "id" => user.ap_id,
	+ "name" => "A new name",
	+ "summary" => "A new bio"
	+ }
	+
	+ {:ok, valid_update, []} = Builder.update(user, object)
	+
	+ %{user: user, valid_update: valid_update}
	+ end
	+
	+ test "validates a basic object", %{valid_update: valid_update} do
	+ assert {:ok, _update, []} = ObjectValidator.validate(valid_update, [])
	+ end
	+ end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 12:32 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723305
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions