No OneTemporary
Actions

Authored By

Unknown

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/ecto_type/activity_pub/object_validators/emoji.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/emoji.ex
	new file mode 100644
	index 000000000..4aacc5c88
	--- /dev/null
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/emoji.ex
	@@ -0,0 +1,34 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.Emoji do
	+ use Ecto.Type
	+
	+ def type, do: :map
	+
	+ def cast(data) when is_map(data) do
	+ has_invalid_emoji? =
	+ Enum.find(data, fn
	+ {name, uri} when is_binary(name) and is_binary(uri) ->
	+ # based on ObjectValidators.Uri.cast()
	+ case URI.parse(uri) do
	+ %URI{host: nil} -> true
	+ %URI{host: ""} -> true
	+ %URI{scheme: scheme} when scheme in ["https", "http"] -> false
	+ _ -> true
	+ end
	+
	+ {_name, _uri} ->
	+ true
	+ end)
	+
	+ if has_invalid_emoji?, do: :error, else: {:ok, data}
	+ end
	+
	+ def cast(_data), do: :error
	+
	+ def dump(data), do: {:ok, data}
	+
	+ def load(data), do: {:ok, data}
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex b/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex
	index d1869f188..1a97c504a 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex
	@@ -1,106 +1,107 @@
	# 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.AudioValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)
	field(:content, :string)
	field(:context, :string)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)

	field(:attributedTo, ObjectValidators.ObjectID)
	field(:summary, :string)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	embeds_many(:attachment, AttachmentValidator)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, :string)
	field(:url, ObjectValidators.Uri)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_url(%{"url" => url} = data) when is_list(url) do
	attachment =
	Enum.find(url, fn x -> is_map(x) and String.starts_with?(x["mimeType"], "audio/") end)

	link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)

	data
	\|> Map.put("attachment", [attachment])
	\|> Map.put("url", link_element["href"])
	end

	defp fix_url(data), do: data

	defp fix(data) do
	data
	\|> CommonFixes.fix_defaults()
	\|> CommonFixes.fix_attribution()
	+ \|> Transmogrifier.fix_emoji()
	\|> fix_url()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment])
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Audio"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :attachment])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex b/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	index 91b475393..6acd4a771 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	@@ -1,129 +1,129 @@
	# 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.ChatMessageValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.Transmogrifier, only: [fix_emoji: 1]

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:type, :string)
	field(:content, ObjectValidators.SafeText)
	field(:actor, ObjectValidators.ObjectID)
	field(:published, ObjectValidators.DateTime)
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})

	embeds_one(:attachment, AttachmentValidator)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def fix(data) do
	data
	\|> fix_emoji()
	\|> fix_attachment()
	\|> Map.put_new("actor", data["attributedTo"])
	end

	# Throws everything but the first one away
	def fix_attachment(%{"attachment" => [attachment \| _]} = data) do
	data
	\|> Map.put("attachment", attachment)
	end

	def fix_attachment(data), do: data

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, List.delete(__schema__(:fields), :attachment))
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["ChatMessage"])
	\|> validate_required([:id, :actor, :to, :type, :published])
	\|> validate_content_or_attachment()
	\|> validate_length(:to, is: 1)
	\|> validate_length(:content, max: Pleroma.Config.get([:instance, :remote_limit]))
	\|> validate_local_concern()
	end

	def validate_content_or_attachment(cng) do
	attachment = get_field(cng, :attachment)

	if attachment do
	cng
	else
	cng
	\|> validate_required([:content])
	end
	end

	@doc """
	Validates the following
	- If both users are in our system
	- If at least one of the users in this ChatMessage is a local user
	- If the recipient is not blocking the actor
	- If the recipient is explicitly not accepting chat messages
	"""
	def validate_local_concern(cng) do
	with actor_ap <- get_field(cng, :actor),
	{_, %User{} = actor} <- {:find_actor, User.get_cached_by_ap_id(actor_ap)},
	{_, %User{} = recipient} <-
	{:find_recipient, User.get_cached_by_ap_id(get_field(cng, :to) \|> hd())},
	{_, false} <- {:not_accepting_chats?, recipient.accepts_chat_messages == false},
	{_, false} <- {:blocking_actor?, User.blocks?(recipient, actor)},
	{_, true} <- {:local?, Enum.any?([actor, recipient], & &1.local)} do
	cng
	else
	{:blocking_actor?, true} ->
	cng
	\|> add_error(:actor, "actor is blocked by recipient")

	{:not_accepting_chats?, true} ->
	cng
	\|> add_error(:to, "recipient does not accept chat messages")

	{:local?, false} ->
	cng
	\|> add_error(:actor, "actor and recipient are both remote")

	{:find_actor, _} ->
	cng
	\|> add_error(:actor, "can't find user")

	{:find_recipient, _} ->
	cng
	\|> add_error(:to, "can't find user")
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	index 07e4821a4..0b4c99dc0 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	@@ -1,96 +1,97 @@
	# 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.EventValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)

	field(:name, :string)
	field(:summary, :string)
	field(:content, :string)

	field(:context, :string)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)

	field(:attributedTo, ObjectValidators.ObjectID)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	embeds_many(:attachment, AttachmentValidator)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.Uri)

	field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix(data) do
	data
	\|> CommonFixes.fix_defaults()
	\|> CommonFixes.fix_attribution()
	+ \|> Transmogrifier.fix_emoji()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment])
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Event"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :context_id])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	index 20e735619..ab4469a59 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	@@ -1,66 +1,73 @@
	# 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.NoteValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)

	field(:name, :string)
	field(:summary, :string)
	field(:content, :string)

	field(:context, :string)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	field(:actor, ObjectValidators.ObjectID)
	field(:attributedTo, ObjectValidators.ObjectID)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	# TODO: Write type
	field(:attachment, {:array, :map}, default: [])
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.Uri)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	+ defp fix(data) do
	+ data
	+ \|> Transmogrifier.fix_emoji()
	+ end
	+
	def cast_data(data) do
	+ data = fix(data)
	+
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Note"])
	\|> validate_required([:id, :actor, :to, :cc, :type, :content, :context])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/question_validator.ex b/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	index 712047424..934d3c1ea 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	@@ -1,111 +1,112 @@
	# 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.QuestionValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionOptionsValidator
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)
	field(:content, :string)
	field(:context, :string)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)

	field(:attributedTo, ObjectValidators.ObjectID)
	field(:summary, :string)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	embeds_many(:attachment, AttachmentValidator)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.Uri)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])

	field(:closed, ObjectValidators.DateTime)
	field(:voters, {:array, ObjectValidators.ObjectID}, default: [])
	embeds_many(:anyOf, QuestionOptionsValidator)
	embeds_many(:oneOf, QuestionOptionsValidator)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_closed(data) do
	cond do
	is_binary(data["closed"]) -> data
	is_binary(data["endTime"]) -> Map.put(data, "closed", data["endTime"])
	true -> Map.drop(data, ["closed"])
	end
	end

	defp fix(data) do
	data
	\|> CommonFixes.fix_defaults()
	\|> CommonFixes.fix_attribution()
	+ \|> Transmogrifier.fix_emoji()
	\|> fix_closed()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:anyOf, :oneOf, :attachment])
	\|> cast_embed(:attachment)
	\|> cast_embed(:anyOf)
	\|> cast_embed(:oneOf)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Question"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :context_id])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_any_presence([:oneOf, :anyOf])
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/test/web/activity_pub/object_validators/chat_validation_test.exs b/test/web/activity_pub/object_validators/chat_validation_test.exs
	index 50bf03515..16e4808e5 100644
	--- a/test/web/activity_pub/object_validators/chat_validation_test.exs
	+++ b/test/web/activity_pub/object_validators/chat_validation_test.exs
	@@ -1,211 +1,212 @@
	# 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.ChatValidationTest 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.CommonAPI

	import Pleroma.Factory

	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
	+ assert match?(%{"firefox" => _}, object["emoji"])
	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 recipient is not accepting chat messages", %{
	valid_chat_message: valid_chat_message,
	recipient: recipient
	} do
	recipient
	\|> Ecto.Changeset.change(%{accepts_chat_messages: false})
	\|> Pleroma.Repo.update!()

	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
	end
	diff --git a/test/web/activity_pub/transmogrifier/question_handling_test.exs b/test/web/activity_pub/transmogrifier/question_handling_test.exs
	index c82361828..74ee79543 100644
	--- a/test/web/activity_pub/transmogrifier/question_handling_test.exs
	+++ b/test/web/activity_pub/transmogrifier/question_handling_test.exs
	@@ -1,125 +1,176 @@
	# 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.Transmogrifier.QuestionHandlingTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

	test "Mastodon Question activity" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()

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

	object = Object.normalize(activity, false)

	assert object.data["url"] == "https://mastodon.sdf.org/@rinpatch/102070944809637304"

	assert object.data["closed"] == "2019-05-11T09:03:36Z"

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

	assert object.data["context"] ==
	"tag:mastodon.sdf.org,2019-05-10:objectId=15095122:objectType=Conversation"

	assert object.data["context_id"]

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

	assert Enum.sort(object.data["oneOf"]) ==
	Enum.sort([
	%{
	"name" => "25 char limit is dumb",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Dunno",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Everyone knows that!",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "I can't even fit a funny",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	}
	])

	user = insert(:user)

	{:ok, reply_activity} = CommonAPI.post(user, %{status: "hewwo", in_reply_to_id: activity.id})

	reply_object = Object.normalize(reply_activity, false)

	assert reply_object.data["context"] == object.data["context"]
	assert reply_object.data["context_id"] == object.data["context_id"]
	end

	test "Mastodon Question activity with HTML tags in plaintext" do
	options = [
	%{
	"type" => "Note",
	"name" => "<input type=\"date\">",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\"/>",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\" />",
	"replies" => %{"totalItems" => 1, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\"></input>",
	"replies" => %{"totalItems" => 1, "type" => "Collection"}
	}
	]

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

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

	assert Enum.sort(object.data["oneOf"]) == Enum.sort(options)
	end

	+ test "Mastodon Question activity with custom emojis" do
	+ options = [
	+ %{
	+ "type" => "Note",
	+ "name" => ":blobcat:",
	+ "replies" => %{"totalItems" => 0, "type" => "Collection"}
	+ },
	+ %{
	+ "type" => "Note",
	+ "name" => ":blobfox:",
	+ "replies" => %{"totalItems" => 0, "type" => "Collection"}
	+ }
	+ ]
	+
	+ tag = [
	+ %{
	+ "icon" => %{
	+ "type" => "Image",
	+ "url" => "https://blob.cat/emoji/custom/blobcats/blobcat.png"
	+ },
	+ "id" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	+ "name" => ":blobcat:",
	+ "type" => "Emoji",
	+ "updated" => "1970-01-01T00:00:00Z"
	+ },
	+ %{
	+ "icon" => %{"type" => "Image", "url" => "https://blob.cat/emoji/blobfox/blobfox.png"},
	+ "id" => "https://blob.cat/emoji/blobfox/blobfox.png",
	+ "name" => ":blobfox:",
	+ "type" => "Emoji",
	+ "updated" => "1970-01-01T00:00:00Z"
	+ }
	+ ]
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-question-activity.json")
	+ \|> Poison.decode!()
	+ \|> Kernel.put_in(["object", "oneOf"], options)
	+ \|> Kernel.put_in(["object", "tag"], tag)
	+
	+ {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity, false)
	+
	+ assert object.data["oneOf"] == options
	+
	+ assert object.data["emoji"] == %{
	+ "blobcat" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	+ "blobfox" => "https://blob.cat/emoji/blobfox/blobfox.png"
	+ }
	+ end
	+
	test "returns an error if received a second time" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()

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

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

	test "accepts a Question with no content" do
	data =
	File.read!("test/fixtures/mastodon-question-activity.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["object", "content"], "")

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

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 1:22 AM (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799086
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions