No OneTemporary
Actions

Authored By

Unknown

Size

44 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/strip-object-actor.fix b/changelog.d/strip-object-actor.fix
	new file mode 100644
	index 000000000..71cf7ee65
	--- /dev/null
	+++ b/changelog.d/strip-object-actor.fix
	@@ -0,0 +1 @@
	+Strip actor property from objects before federating
	diff --git a/lib/pleroma/constants.ex b/lib/pleroma/constants.ex
	index 3a5e35301..ac4bf2ffb 100644
	--- a/lib/pleroma/constants.ex
	+++ b/lib/pleroma/constants.ex
	@@ -1,110 +1,111 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Constants do
	use Const

	const(as_public, do: "https://www.w3.org/ns/activitystreams#Public")

	const(object_internal_fields,
	do: [
	+ "actor",
	"reactions",
	"reaction_count",
	"likes",
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id",
	"deleted_activity_id",
	"pleroma_internal",
	"generator",
	"rules"
	]
	)

	const(static_only_files,
	do:
	~w(index.html robots.txt static static-fe finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc embed.js embed.css)
	)

	const(status_updatable_fields,
	do: [
	"source",
	"tag",
	"updated",
	"emoji",
	"content",
	"summary",
	"sensitive",
	"attachment",
	"generator"
	]
	)

	const(status_object_types,
	do: [
	"Note",
	"Question",
	"Audio",
	"Video",
	"Event",
	"Article",
	"Page"
	]
	)

	const(updatable_object_types,
	do: [
	"Note",
	"Question",
	"Audio",
	"Video",
	"Event",
	"Article",
	"Page"
	]
	)

	const(actor_types,
	do: [
	"Application",
	"Group",
	"Organization",
	"Person",
	"Service"
	]
	)

	const(allowed_user_actor_types,
	do: [
	"Person",
	"Service",
	"Group"
	]
	)

	# basic regex, just there to weed out potential mistakes
	# https://datatracker.ietf.org/doc/html/rfc2045#section-5.1
	const(mime_regex,
	do: ~r/^[^[:cntrl:] ()<>@,;:\\"\/\[\]?=]+\/[^[:cntrl:] ()<>@,;:\\"\/\[\]?=]+(; .*)?$/
	)

	const(upload_object_types, do: ["Document", "Image"])

	const(activity_json_canonical_mime_type,
	do: "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)

	const(activity_json_mime_types,
	do: [
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"application/activity+json"
	]
	)

	const(public_streams,
	do: ["public", "public:local", "public:media", "public:local:media"]
	)
	end
	diff --git a/test/fixtures/create-chat-message.json b/test/fixtures/create-chat-message.json
	index 9c23a1c9b..a5e5f559b 100644
	--- a/test/fixtures/create-chat-message.json
	+++ b/test/fixtures/create-chat-message.json
	@@ -1,31 +1,31 @@
	{
	- "actor": "http://2hu.gensokyo/users/raymoo",
	- "id": "http://2hu.gensokyo/objects/1",
	+ "actor": "http://mastodon.example.org/users/admin",
	+ "id": "http://mastodon.example.org/objects/1",
	"object": {
	- "attributedTo": "http://2hu.gensokyo/users/raymoo",
	+ "attributedTo": "http://mastodon.example.org/users/admin",
	"content": "You expected a cute girl? Too bad. <script>alert('XSS')</script>",
	- "id": "http://2hu.gensokyo/objects/2",
	+ "id": "http://mastodon.example.org/objects/2",
	"published": "2020-02-12T14:08:20Z",
	"to": [
	"http://2hu.gensokyo/users/marisa"
	],
	"tag": [
	{
	"icon": {
	"type": "Image",
	"url": "http://2hu.gensokyo/emoji/Firefox.gif"
	},
	"id": "http://2hu.gensokyo/emoji/Firefox.gif",
	"name": ":firefox:",
	"type": "Emoji",
	"updated": "1970-01-01T00:00:00Z"
	}
	],
	"type": "ChatMessage"
	},
	"published": "2018-02-12T14:08:20Z",
	"to": [
	"http://2hu.gensokyo/users/marisa"
	],
	"type": "Create"
	}
	diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
	index 5503d15bc..e7187df35 100644
	--- a/test/pleroma/user/backup_test.exs
	+++ b/test/pleroma/user/backup_test.exs
	@@ -1,372 +1,370 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.BackupTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	import Mock
	import Pleroma.Factory
	import Swoosh.TestAssertions
	import Mox

	alias Pleroma.Bookmark
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Uploaders.S3.ExAwsMock
	alias Pleroma.User.Backup
	alias Pleroma.User.Backup.ProcessorMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.BackupWorker

	setup do
	clear_config([Pleroma.Upload, :uploader])
	clear_config([Backup, :limit_days])
	clear_config([Pleroma.Emails.Mailer, :enabled], true)

	ConfigMock
	\|> stub_with(Pleroma.Config)

	ProcessorMock
	\|> stub_with(Pleroma.User.Backup.Processor)

	:ok
	end

	test "it does not requrie enabled email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	user = insert(:user)
	assert {:ok, _} = Backup.create(user)
	end

	test "it does not require user's email" do
	user = insert(:user, %{email: nil})
	assert {:ok, _} = Backup.create(user)
	end

	test "it creates a backup record and an Oban job" do
	%{id: user_id} = user = insert(:user)
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	assert_enqueued(worker: BackupWorker, args: args)

	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0, state: :pending} = backup
	end

	test "it return an error if the export limit is over" do
	%{id: user_id} = user = insert(:user)
	limit_days = Pleroma.Config.get([Backup, :limit_days])
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup

	assert Backup.create(user) == {:error, "Last export was less than #{limit_days} days ago"}
	end

	test "it process a backup record" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id, state: :complete} = backup

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it updates states of the backup" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id, state: :complete} = backup

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it does not send an email if the user does not have an email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: nil})

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it does not send an email if mailer is not on" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it does not send an email if the user has an empty email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: ""})

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it removes outdated backups after creating a fresh one" do
	clear_config([Backup, :limit_days], -1)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	user = insert(:user)

	assert {:ok, job1} = Backup.create(user)

	assert {:ok, %Backup{}} = ObanHelpers.perform(job1)
	assert {:ok, job2} = Backup.create(user)
	assert Pleroma.Repo.aggregate(Backup, :count) == 2
	assert {:ok, backup2} = ObanHelpers.perform(job2)

	ObanHelpers.perform_all()

	assert [^backup2] = Pleroma.Repo.all(Backup)
	end

	test "it creates a zip archive with user data" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
	%{ap_id: other_ap_id} = other_user = insert(:user)

	{:ok, %{object: %{data: %{"id" => id1}}} = status1} =
	CommonAPI.post(user, %{status: "status1"})

	{:ok, %{object: %{data: %{"id" => id2}}} = status2} =
	CommonAPI.post(user, %{status: "status2"})

	{:ok, %{object: %{data: %{"id" => id3}}} = status3} =
	CommonAPI.post(user, %{status: "status3"})

	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)

	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	CommonAPI.follow(user, other_user)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup, self())
	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
	assert {:ok, {'actor.json', json}} = :zip.zip_get('actor.json', zipfile)

	assert %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{"@language" => "und"}
	],
	"bookmarks" => "bookmarks.json",
	"followers" => "http://cofe.io/users/cofe/followers",
	"following" => "http://cofe.io/users/cofe/following",
	"id" => "http://cofe.io/users/cofe",
	"inbox" => "http://cofe.io/users/cofe/inbox",
	"likes" => "likes.json",
	"name" => "Cofe",
	"outbox" => "http://cofe.io/users/cofe/outbox",
	"preferredUsername" => "cofe",
	"publicKey" => %{
	"id" => "http://cofe.io/users/cofe#main-key",
	"owner" => "http://cofe.io/users/cofe"
	},
	"type" => "Person",
	"url" => "http://cofe.io/users/cofe"
	} = Jason.decode!(json)

	assert {:ok, {'outbox.json', json}} = :zip.zip_get('outbox.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "outbox.json",
	"orderedItems" => [
	%{
	"object" => %{
	- "actor" => "http://cofe.io/users/cofe",
	"content" => "status1",
	"type" => "Note"
	},
	"type" => "Create"
	},
	%{
	"object" => %{
	- "actor" => "http://cofe.io/users/cofe",
	"content" => "status2"
	}
	},
	%{
	"actor" => "http://cofe.io/users/cofe",
	"object" => %{
	"content" => "status3"
	}
	}
	],
	"totalItems" => 3,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {'likes.json', json}} = :zip.zip_get('likes.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "likes.json",
	"orderedItems" => [^id1, ^id2],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {'bookmarks.json', json}} = :zip.zip_get('bookmarks.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "bookmarks.json",
	"orderedItems" => [^id2, ^id3],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {'following.json', json}} = :zip.zip_get('following.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "following.json",
	"orderedItems" => [^other_ap_id],
	"totalItems" => 1,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	:zip.zip_close(zipfile)
	File.rm!(path)
	end

	test "it counts the correct number processed" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	Enum.map(1..120, fn i ->
	{:ok, status} = CommonAPI.post(user, %{status: "status #{i}"})
	CommonAPI.favorite(user, status.id)
	Bookmark.create(user.id, status.id)
	end)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	{:ok, backup} = Backup.process(backup)

	assert backup.processed_number == 1 + 120 + 120 + 120

	Backup.delete(backup)
	end

	test "it handles errors" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	Enum.map(1..120, fn i ->
	{:ok, _status} = CommonAPI.post(user, %{status: "status #{i}"})
	end)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()

	with_mock Pleroma.Web.ActivityPub.Transmogrifier,
	[:passthrough],
	prepare_outgoing: fn data ->
	object =
	data["object"]
	\|> Pleroma.Object.normalize(fetch: false)
	\|> Map.get(:data)

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

	if String.contains?(data["object"]["content"], "119"),
	do: raise(%Postgrex.Error{}),
	else: {:ok, data}
	end do
	{:ok, backup} = Backup.process(backup)
	assert backup.processed
	assert backup.state == :complete
	assert backup.processed_number == 1 + 119

	Backup.delete(backup)
	end
	end

	describe "it uploads and deletes a backup archive" do
	setup do
	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
	clear_config([Pleroma.Uploaders.S3, :bucket], "test_bucket")

	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	{:ok, status1} = CommonAPI.post(user, %{status: "status1"})
	{:ok, status2} = CommonAPI.post(user, %{status: "status2"})
	{:ok, status3} = CommonAPI.post(user, %{status: "status3"})
	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)
	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup, self())

	[path: path, backup: backup]
	end

	test "S3", %{path: path, backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
	clear_config([Pleroma.Uploaders.S3, :streaming_enabled], false)

	ExAwsMock
	\|> expect(:request, 2, fn
	%{http_method: :put} -> {:ok, :ok}
	%{http_method: :delete} -> {:ok, %{status_code: 204}}
	end)

	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end

	test "Local", %{path: path, backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs b/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs
	index c798a0fc9..086641750 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs
	@@ -1,171 +1,169 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.ChatMessageTest do
	use Pleroma.DataCase

	import Pleroma.Factory

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

	describe "handle_incoming" do
	test "handles chonks with attachment" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://honk.tedunangst.com/u/tedu",
	"id" => "https://honk.tedunangst.com/u/tedu/honk/x6gt8X8PcyGkQcXxzg1T",
	"object" => %{
	"attachment" => [
	%{
	"mediaType" => "image/jpeg",
	"name" => "298p3RG7j27tfsZ9RQ.jpg",
	"summary" => "298p3RG7j27tfsZ9RQ.jpg",
	"type" => "Document",
	"url" => "https://honk.tedunangst.com/d/298p3RG7j27tfsZ9RQ.jpg"
	}
	],
	"attributedTo" => "https://honk.tedunangst.com/u/tedu",
	"content" => "",
	"id" => "https://honk.tedunangst.com/u/tedu/chonk/26L4wl5yCbn4dr4y1b",
	"published" => "2020-05-18T01:13:03Z",
	"to" => [
	"https://dontbulling.me/users/lain"
	],
	"type" => "ChatMessage"
	},
	"published" => "2020-05-18T01:13:03Z",
	"to" => [
	"https://dontbulling.me/users/lain"
	],
	"type" => "Create"
	}

	_user = insert(:user, ap_id: data["actor"])
	_user = insert(:user, ap_id: hd(data["to"]))

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

	test "it rejects messages that don't contain content" do
	data =
	File.read!("test/fixtures/create-chat-message.json")
	\|> Jason.decode!()

	object =
	data["object"]
	\|> Map.delete("content")

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

	_author =
	insert(:user, ap_id: data["actor"], local: false, last_refreshed_at: DateTime.utc_now())

	_recipient =
	insert(:user,
	ap_id: List.first(data["to"]),
	local: true,
	last_refreshed_at: DateTime.utc_now()
	)

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

	test "it rejects messages that don't concern local users" do
	data =
	File.read!("test/fixtures/create-chat-message.json")
	\|> Jason.decode!()

	_author =
	insert(:user, ap_id: data["actor"], local: false, last_refreshed_at: DateTime.utc_now())

	_recipient =
	insert(:user,
	ap_id: List.first(data["to"]),
	local: false,
	last_refreshed_at: DateTime.utc_now()
	)

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

	test "it rejects messages where the `to` field of activity and object don't match" do
	data =
	File.read!("test/fixtures/create-chat-message.json")
	\|> Jason.decode!()

	author = insert(:user, ap_id: data["actor"])
	_recipient = insert(:user, ap_id: List.first(data["to"]))

	data =
	data
	\|> Map.put("to", author.ap_id)

	assert match?({:error, _}, Transmogrifier.handle_incoming(data))
	refute Object.get_by_ap_id(data["object"]["id"])
	end

	test "it fetches the actor if they aren't in our system" do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)

	data =
	File.read!("test/fixtures/create-chat-message.json")
	\|> Jason.decode!()
	- \|> Map.put("actor", "http://mastodon.example.org/users/admin")
	- \|> put_in(["object", "actor"], "http://mastodon.example.org/users/admin")

	_recipient = insert(:user, ap_id: List.first(data["to"]), local: true)

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

	test "it doesn't work for deactivated users" do
	data =
	File.read!("test/fixtures/create-chat-message.json")
	\|> Jason.decode!()

	_author =
	insert(:user,
	ap_id: data["actor"],
	local: false,
	last_refreshed_at: DateTime.utc_now(),
	is_active: false
	)

	_recipient = insert(:user, ap_id: List.first(data["to"]), local: true)

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

	test "it inserts it and creates a chat" do
	data =
	File.read!("test/fixtures/create-chat-message.json")
	\|> Jason.decode!()

	author =
	insert(:user, ap_id: data["actor"], local: false, last_refreshed_at: DateTime.utc_now())

	recipient = insert(:user, ap_id: List.first(data["to"]), local: true)

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

	assert activity.actor == author.ap_id
	assert activity.recipients == [recipient.ap_id, author.ap_id]

	%Object{} = object = Object.get_by_ap_id(activity.data["object"])

	assert object
	assert object.data["content"] == "You expected a cute girl? Too bad. alert('XSS')"
	assert match?(%{"firefox" => _}, object.data["emoji"])

	refute Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index a49e459a6..5d84b8403 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,626 +1,627 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

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

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

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

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

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

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

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

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})
	object = Object.normalize(activity, fetch: false)

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

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, activity.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

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

	assert activity.data["object"] == [user.ap_id, note_obj]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it accepts Move activities" do
	old_user = insert(:user)
	new_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Move",
	"actor" => old_user.ap_id,
	"object" => old_user.ap_id,
	"target" => new_user.ap_id
	}

	assert :error = Transmogrifier.handle_incoming(message)

	{:ok, _new_user} = User.update_and_set_cache(new_user, %{also_known_as: [old_user.ap_id]})

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(message)
	assert activity.actor == old_user.ap_id
	assert activity.data["actor"] == old_user.ap_id
	assert activity.data["object"] == old_user.ap_id
	assert activity.data["target"] == new_user.ap_id
	assert activity.data["type"] == "Move"
	end

	test "it fixes both the Create and object contexts in a reply" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")
	insert(:user, ap_id: "https://p.helene.moe/users/helene")

	create_activity =
	"test/fixtures/create-pleroma-reply-to-misskey-thread.json"
	\|> File.read!()
	\|> Jason.decode!()

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

	object = Object.normalize(activity, fetch: false)

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

	test "it keeps link tags" do
	insert(:user, ap_id: "https://example.org/users/alice")

	message = File.read!("test/fixtures/fep-e232.json") \|> Jason.decode!()

	assert capture_log(fn ->
	assert {:ok, activity} = Transmogrifier.handle_incoming(message)
	object = Object.normalize(activity)
	assert [%{"type" => "Mention"}, %{"type" => "Link"}] = object.data["tag"]
	end) =~ "Object rejected while fetching"
	end

	test "it accepts quote posts" do
	insert(:user, ap_id: "https://misskey.io/users/7rkrarq81i")

	object = File.read!("test/fixtures/quote_post/misskey_quote_post.json") \|> Jason.decode!()

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => "https://misskey.io/users/7rkrarq81i",
	"object" => object
	}

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

	# Object was created in the database
	object = Object.normalize(activity)
	assert object.data["quoteUrl"] == "https://misskey.io/notes/8vs6wxufd0"

	# It fetched the quoted post
	assert Object.normalize("https://misskey.io/notes/8vs6wxufd0")
	end
	end

	describe "prepare outgoing" do
	test "it inlines private announced objects" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey", visibility: "private"})

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)

	{:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)

	assert modified["object"]["content"] == "hey"
	- assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	+ assert activity.actor == modified["object"]["attributedTo"]
	end

	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})

	with_mock Pleroma.Notification,
	get_notified_from_activity: fn _, _ -> [] end do
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	refute called(Pleroma.Notification.get_notified_from_activity(:_, :_))
	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

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

	assert modified["@context"] == Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

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

	- assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	+ assert activity.actor == modified["object"]["attributedTo"]
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu"})

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

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

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "#2hu :firefox:",
	generator: %{type: "Application", name: "TestClient", url: "https://pleroma.social"}
	})

	# Ensure injected application data made it into the activity
	# as we don't have a Token to derive it from, otherwise it will
	# be nil and the test will pass
	assert %{
	type: "Application",
	name: "TestClient",
	url: "https://pleroma.social"
	} == activity.object.data["generator"]

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

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["generator"])
	+ assert is_nil(modified["object"]["actor"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

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

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["likes"])
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "2hu :moominmamma:"})

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

	assert modified["directMessage"] == false

	{:ok, activity} = CommonAPI.post(user, %{status: "@#{other_user.nickname} :moominmamma:"})

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

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} :moominmamma:",
	visibility: "direct"
	})

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

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

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

	assert is_nil(modified["bcc"])
	end

	test "it can handle Listen activities" do
	listen_activity = insert(:listen)

	{:ok, modified} = Transmogrifier.prepare_outgoing(listen_activity.data)

	assert modified["type"] == "Listen"

	user = insert(:user)

	{:ok, activity} = CommonAPI.listen(user, %{"title" => "lain radio episode 1"})

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

	test "custom emoji urls are URI encoded" do
	# :dinosaur: filename has a space -> dino walking.gif
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})

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

	assert length(prepared["object"]["tag"]) == 1

	url = prepared["object"]["tag"] \|> List.first() \|> Map.get("icon") \|> Map.get("url")

	assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	end

	test "Updates of Notes are handled" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})
	{:ok, update} = CommonAPI.update(user, activity, %{status: "mew mew :blank:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(update.data)

	assert %{
	"content" => "mew mew :blank:",
	"tag" => [%{"name" => ":blank:", "type" => "Emoji"}],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"content" => "everybody do the dinosaur :dinosaur:",
	"tag" => [%{"name" => ":dinosaur:", "type" => "Emoji"}]
	}
	]
	}
	} = prepared["object"]
	end

	test "it prepares a quote post" do
	user = insert(:user)

	{:ok, quoted_post} = CommonAPI.post(user, %{status: "hey"})
	{:ok, quote_post} = CommonAPI.post(user, %{status: "hey", quote_id: quoted_post.id})

	{:ok, modified} = Transmogrifier.prepare_outgoing(quote_post.data)

	%{data: %{"id" => quote_id}} = Object.normalize(quoted_post)

	assert modified["object"]["quoteUrl"] == quote_id
	assert modified["object"]["quoteUri"] == quote_id
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end

	describe "fix_summary/1" do
	test "returns fixed object" do
	assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
	assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
	assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
	end
	end

	describe "fix_url/1" do
	test "fixes data for object when url is map" do
	object = %{
	"url" => %{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	}

	assert Transmogrifier.fix_url(object) == %{
	"url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	end

	test "returns non-modified object" do
	assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
	end
	end

	describe "get_obj_helper/2" do
	test "returns nil when cannot normalize object" do
	assert capture_log(fn ->
	refute Transmogrifier.get_obj_helper("test-obj-id")
	end) =~ "Unsupported URI scheme"
	end

	@tag capture_log: true
	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)
	end
	end

	describe "fix_attachments/1" do
	test "puts dimensions into attachment url field" do
	object = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960,
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	expected = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpeg",
	"href" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960
	}
	],
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	assert Transmogrifier.fix_attachments(object) == expected
	end
	end

	describe "prepare_object/1" do
	test "it processes history" do
	original = %{
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)

	history_item = Enum.at(processed["formerRepresentations"]["orderedItems"], 0)

	refute Map.has_key?(history_item, "generator")

	assert [%{"name" => ":blobcat:"}] = history_item["tag"]
	end

	test "it works when there is no or bad history" do
	original = %{
	"formerRepresentations" => %{
	"items" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)
	assert processed["formerRepresentations"] == original["formerRepresentations"]
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 11:45 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798069
Default Alt Text: (44 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions