No OneTemporary
Actions

Authored By

Unknown

Size

115 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/mix/pleroma_test.exs b/test/mix/pleroma_test.exs
	index e362223b2..e8f801913 100644
	--- a/test/mix/pleroma_test.exs
	+++ b/test/mix/pleroma_test.exs
	@@ -1,50 +1,50 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.PleromaTest do
	- use ExUnit.Case, async: true
	+ use ExUnit.Case, async: false
	import Mix.Pleroma

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "shell_prompt/1" do
	test "input" do
	send(self(), {:mix_shell_input, :prompt, "Yes"})

	answer = shell_prompt("Do you want this?")
	assert_received {:mix_shell, :prompt, [message]}
	assert message =~ "Do you want this?"
	assert answer == "Yes"
	end

	test "with defval" do
	send(self(), {:mix_shell_input, :prompt, "\n"})

	answer = shell_prompt("Do you want this?", "defval")

	assert_received {:mix_shell, :prompt, [message]}
	assert message =~ "Do you want this? [defval]"
	assert answer == "defval"
	end
	end

	describe "get_option/3" do
	test "get from options" do
	assert get_option([domain: "some-domain.com"], :domain, "Prompt") == "some-domain.com"
	end

	test "get from prompt" do
	send(self(), {:mix_shell_input, :prompt, "another-domain.com"})
	assert get_option([], :domain, "Prompt") == "another-domain.com"
	end
	end
	end
	diff --git a/test/mix/tasks/pleroma/app_test.exs b/test/mix/tasks/pleroma/app_test.exs
	index 65245eadd..6156214c1 100644
	--- a/test/mix/tasks/pleroma/app_test.exs
	+++ b/test/mix/tasks/pleroma/app_test.exs
	@@ -1,66 +1,66 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.AppTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)
	end

	describe "creates new app" do
	test "with default scopes" do
	name = "Some name"
	redirect = "https://example.com"
	Mix.Tasks.Pleroma.App.run(["create", "-n", name, "-r", redirect])

	assert_app(name, redirect, ["read", "write", "follow", "push"])
	end

	test "with custom scopes" do
	name = "Another name"
	redirect = "https://example.com"

	Mix.Tasks.Pleroma.App.run([
	"create",
	"-n",
	name,
	"-r",
	redirect,
	"-s",
	"read,write,follow,push,admin"
	])

	assert_app(name, redirect, ["read", "write", "follow", "push", "admin"])
	end
	end

	test "with errors" do
	Mix.Tasks.Pleroma.App.run(["create"])

	assert_receive {:mix_shell, :error, ["Creating failed:"]}
	assert_receive {:mix_shell, :error, ["name: can't be blank"]}
	assert_receive {:mix_shell, :error, ["redirect_uris: can't be blank"]}
	end

	defp assert_app(name, redirect, scopes) do
	app = Repo.get_by(Pleroma.Web.OAuth.App, client_name: name)

	assert_receive {:mix_shell, :info, [message]}
	assert message == "#{name} successfully created:"

	assert_receive {:mix_shell, :info, [message]}
	assert message == "App client_id: #{app.client_id}"

	assert_receive {:mix_shell, :info, [message]}
	assert message == "App client_secret: #{app.client_secret}"

	assert app.scopes == scopes
	assert app.redirect_uris == redirect
	end
	end
	diff --git a/test/mix/tasks/pleroma/database_test.exs b/test/mix/tasks/pleroma/database_test.exs
	index 38ed096ae..19df17b60 100644
	--- a/test/mix/tasks/pleroma/database_test.exs
	+++ b/test/mix/tasks/pleroma/database_test.exs
	@@ -1,660 +1,660 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.DatabaseTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running remove_embedded_objects" do
	test "it replaces objects with references" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "test"})
	new_data = Map.put(activity.data, "object", activity.object.data)

	{:ok, activity} =
	activity
	\|> Activity.change(%{data: new_data})
	\|> Repo.update()

	assert is_map(activity.data["object"])

	Mix.Tasks.Pleroma.Database.run(["remove_embedded_objects"])

	activity = Activity.get_by_id_with_object(activity.id)
	assert is_binary(activity.data["object"])
	end
	end

	describe "prune_objects" do
	setup do
	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days]) + 1

	old_insert_date =
	Timex.now()
	\|> Timex.shift(days: -deadline)
	\|> Timex.to_naive_datetime()
	\|> NaiveDateTime.truncate(:second)

	%{old_insert_date: old_insert_date}
	end

	test "it prunes old objects from the database", %{old_insert_date: old_insert_date} do
	insert(:note)

	%{id: note_remote_public_id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	note_remote_non_public =
	%{id: note_remote_non_public_id, data: note_remote_non_public_data} =
	:note
	\|> insert()

	note_remote_non_public
	\|> Ecto.Changeset.change(%{
	updated_at: old_insert_date,
	data: note_remote_non_public_data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	refute Object.get_by_id(note_remote_public_id)
	refute Object.get_by_id(note_remote_non_public_id)
	end

	test "it cleans up bookmarks", %{old_insert_date: old_insert_date} do
	user = insert(:user)
	{:ok, old_object_activity} = CommonAPI.post(user, %{status: "yadayada"})

	Repo.one(Object)
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, new_object_activity} = CommonAPI.post(user, %{status: "yadayada"})

	{:ok, _} = Bookmark.create(user.id, old_object_activity.id)
	{:ok, _} = Bookmark.create(user.id, new_object_activity.id)

	assert length(Repo.all(Object)) == 2
	assert length(Repo.all(Bookmark)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	assert length(Repo.all(Bookmark)) == 1
	refute Bookmark.get(user.id, old_object_activity.id)
	end

	test "with the --keep-non-public option it still keeps non-public posts even if they are not local",
	%{old_insert_date: old_insert_date} do
	insert(:note)

	%{id: note_remote_id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{updated_at: old_insert_date})
	\|> Repo.update!()

	note_remote_non_public =
	%{data: note_remote_non_public_data} =
	:note
	\|> insert()

	note_remote_non_public
	\|> Ecto.Changeset.change(%{
	updated_at: old_insert_date,
	data: note_remote_non_public_data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-non-public"])

	assert length(Repo.all(Object)) == 2
	refute Object.get_by_id(note_remote_id)
	end

	test "with the --keep-threads and --keep-non-public option it keeps old threads with non-public replies even if the interaction is not local",
	%{old_insert_date: old_insert_date} do
	# For non-public we only check Create Activities because only these are relevant for threads
	# Flags are always non-public, Announces from relays can be non-public...

	remote_user1 = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	# Old remote non-public reply (should be kept)
	{:ok, old_remote_post1_activity} =
	CommonAPI.post(remote_user1, %{status: "some thing", local: false})

	old_remote_post1_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_non_public_reply_activity} =
	CommonAPI.post(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post1_activity.id
	})

	old_remote_non_public_reply_activity
	\|> Ecto.Changeset.change(%{
	local: false,
	updated_at: old_insert_date,
	data: old_remote_non_public_reply_activity.data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	# Old remote non-public Announce (should be removed)
	{:ok, old_remote_post2_activity = %{data: %{"object" => old_remote_post2_id}}} =
	CommonAPI.post(remote_user1, %{status: "some thing", local: false})

	old_remote_post2_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_non_public_repeat_activity} =
	CommonAPI.repeat(old_remote_post2_activity.id, remote_user2)

	old_remote_non_public_repeat_activity
	\|> Ecto.Changeset.change(%{
	local: false,
	updated_at: old_insert_date,
	data: old_remote_non_public_repeat_activity.data \|> update_in(["to"], fn _ -> [] end)
	})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 3

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads", "--keep-non-public"])

	Repo.all(Pleroma.Activity)
	assert length(Repo.all(Object)) == 2
	refute Object.get_by_ap_id(old_remote_post2_id)
	end

	test "with the --keep-threads option it still keeps non-old threads even with no local interactions" do
	remote_user = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	{:ok, remote_post_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	{:ok, remote_post_reply_activity} =
	CommonAPI.post(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: remote_post_activity.id
	})

	remote_post_activity
	\|> Ecto.Changeset.change(%{local: false})
	\|> Repo.update!()

	remote_post_reply_activity
	\|> Ecto.Changeset.change(%{local: false})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 2
	end

	test "with the --keep-threads option it deletes old threads with no local interaction", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	remote_user2 = insert(:user, local: false)

	{:ok, old_remote_post_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_remote_post_reply_activity} =
	CommonAPI.post(remote_user2, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post_activity.id
	})

	old_remote_post_reply_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_favourite_activity} =
	CommonAPI.favorite(old_remote_post_activity.id, remote_user2)

	old_favourite_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_repeat_activity} = CommonAPI.repeat(old_remote_post_activity.id, remote_user2)

	old_repeat_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 0
	end

	test "with the --keep-threads option it keeps old threads with local interaction", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	local_user = insert(:user, local: true)

	# local reply
	{:ok, old_remote_post1_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post1_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_local_post2_reply_activity} =
	CommonAPI.post(local_user, %{
	status: "some reply",
	in_reply_to_status_id: old_remote_post1_activity.id
	})

	old_local_post2_reply_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	# local Like
	{:ok, old_remote_post3_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post3_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_favourite_activity} = CommonAPI.favorite(old_remote_post3_activity.id, local_user)

	old_favourite_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	# local Announce
	{:ok, old_remote_post4_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post4_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	{:ok, old_repeat_activity} = CommonAPI.repeat(old_remote_post4_activity.id, local_user)

	old_repeat_activity
	\|> Ecto.Changeset.change(%{local: true, updated_at: old_insert_date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 4

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 4
	end

	test "with the --keep-threads option it keeps old threads with bookmarked posts", %{
	old_insert_date: old_insert_date
	} do
	remote_user = insert(:user, local: false)
	local_user = insert(:user, local: true)

	{:ok, old_remote_post_activity} =
	CommonAPI.post(remote_user, %{status: "some thing", local: false})

	old_remote_post_activity
	\|> Ecto.Changeset.change(%{local: false, updated_at: old_insert_date})
	\|> Repo.update!()

	Pleroma.Bookmark.create(local_user.id, old_remote_post_activity.id)

	assert length(Repo.all(Object)) == 1

	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--keep-threads"])

	assert length(Repo.all(Object)) == 1
	end

	test "We don't have unexpected tables which may contain objects that are referenced by activities" do
	# We can delete orphaned activities. For that we look for the objects
	# they reference in the 'objects', 'activities', and 'users' table.
	# If someone adds another table with objects (idk, maybe with separate
	# relations, or collections or w/e), then we need to make sure we
	# add logic for that in the 'prune_objects' task so that we don't
	# wrongly delete their corresponding activities.
	# So when someone adds (or removes) a table, this test will fail.
	# Either the table contains objects which can be referenced from the
	# activities table
	# => in that case the prune_objects job should be adapted so we don't
	# delete activities who still have the referenced object.
	# Or it doesn't contain objects which can be referenced from the activities table
	# => in that case you can add/remove the table to/from this (sorted) list.

	assert Repo.query!(
	"SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';"
	).rows
	\|> Enum.sort() == [
	["activities"],
	["announcement_read_relationships"],
	["announcements"],
	["apps"],
	["backups"],
	["bookmark_folders"],
	["bookmarks"],
	["chat_message_references"],
	["chats"],
	["config"],
	["conversation_participation_recipient_ships"],
	["conversation_participations"],
	["conversations"],
	["counter_cache"],
	["data_migration_failed_ids"],
	["data_migrations"],
	["deliveries"],
	["filters"],
	["following_relationships"],
	["hashtags"],
	["hashtags_objects"],
	["instances"],
	["lists"],
	["markers"],
	["mfa_tokens"],
	["moderation_log"],
	["notifications"],
	["oauth_authorizations"],
	["oauth_tokens"],
	["oban_jobs"],
	["oban_peers"],
	["objects"],
	["password_reset_tokens"],
	["push_subscriptions"],
	["registrations"],
	["report_notes"],
	["rich_media_card"],
	["rules"],
	["scheduled_activities"],
	["schema_migrations"],
	["thread_mutes"],
	["user_follows_hashtag"],
	# ["user_frontend_setting_profiles"], # not in pleroma
	["user_invite_tokens"],
	["user_notes"],
	["user_relationships"],
	["users"]
	]
	end

	test "it prunes orphaned activities with the --prune-orphaned-activities" do
	# Add a remote activity which references an Object
	%Object{} \|> Map.merge(%{data: %{"id" => "object_for_activity"}}) \|> Repo.insert()

	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{"id" => "remote_activity_with_object", "object" => "object_for_activity"}
	})
	\|> Repo.insert()

	# Add a remote activity which references an activity
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_with_activity",
	"object" => "remote_activity_with_object"
	}
	})
	\|> Repo.insert()

	# Add a remote activity which references an Actor
	%User{} \|> Map.merge(%{ap_id: "actor"}) \|> Repo.insert()

	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{"id" => "remote_activity_with_actor", "object" => "actor"}
	})
	\|> Repo.insert()

	# Add a remote activity without existing referenced object, activity or actor
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_without_existing_referenced_object",
	"object" => "non_existing"
	}
	})
	\|> Repo.insert()

	# Add a local activity without existing referenced object, activity or actor
	%Activity{}
	\|> Map.merge(%{
	local: true,
	data: %{"id" => "local_activity_with_actor", "object" => "non_existing"}
	})
	\|> Repo.insert()

	# The remote activities without existing reference,
	# and only the remote activities without existing reference, are deleted
	# if, and only if, we provide the --prune-orphaned-activities option
	assert length(Repo.all(Activity)) == 5
	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Activity)) == 5
	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--prune-orphaned-activities"])
	activities = Repo.all(Activity)

	assert "remote_activity_without_existing_referenced_object" not in Enum.map(
	activities,
	fn a -> a.data["id"] end
	)

	assert length(activities) == 4
	end

	test "it prunes orphaned activities with the --prune-orphaned-activities when the objects are referenced from an array" do
	%Object{} \|> Map.merge(%{data: %{"id" => "existing_object"}}) \|> Repo.insert()
	%User{} \|> Map.merge(%{ap_id: "existing_actor"}) \|> Repo.insert()

	# Multiple objects, one object exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_object",
	"object" => ["non_ existing_object", "existing_object"]
	}
	})
	\|> Repo.insert()

	# Multiple objects, one actor exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_actor",
	"object" => ["non_ existing_object", "existing_actor"]
	}
	})
	\|> Repo.insert()

	# Multiple objects, one activity exists (keep)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_existing_activity",
	"object" => ["non_ existing_object", "remote_activity_existing_actor"]
	}
	})
	\|> Repo.insert()

	# Multiple objects none exist (prune)
	%Activity{}
	\|> Map.merge(%{
	local: false,
	data: %{
	"id" => "remote_activity_without_existing_referenced_object",
	"object" => ["owo", "whats_this"]
	}
	})
	\|> Repo.insert()

	assert length(Repo.all(Activity)) == 4
	Mix.Tasks.Pleroma.Database.run(["prune_objects"])
	assert length(Repo.all(Activity)) == 4
	Mix.Tasks.Pleroma.Database.run(["prune_objects", "--prune-orphaned-activities"])
	activities = Repo.all(Activity)
	assert length(activities) == 3

	assert "remote_activity_without_existing_referenced_object" not in Enum.map(
	activities,
	fn a -> a.data["id"] end
	)

	assert length(activities) == 3
	end
	end

	describe "running update_users_following_followers_counts" do
	test "following and followers count are updated" do
	[user, user2] = insert_pair(:user)
	{:ok, %User{} = user, _user2} = User.follow(user, user2)

	following = User.following(user)

	assert length(following) == 2
	assert user.follower_count == 0

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{follower_count: 3})
	\|> Repo.update()

	assert user.follower_count == 3

	assert {:ok, :ok} ==
	Mix.Tasks.Pleroma.Database.run(["update_users_following_followers_counts"])

	user = User.get_by_id(user.id)

	assert length(User.following(user)) == 2
	assert user.follower_count == 0
	end
	end

	describe "running fix_likes_collections" do
	test "it turns OrderedCollection likes into empty arrays" do
	[user, user2] = insert_pair(:user)

	{:ok, %{id: id, object: object}} = CommonAPI.post(user, %{status: "test"})
	{:ok, %{object: object2}} = CommonAPI.post(user, %{status: "test test"})

	CommonAPI.favorite(id, user2)

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

	new_data = Map.put(object2.data, "likes", likes)

	object2
	\|> Ecto.Changeset.change(%{data: new_data})
	\|> Repo.update()

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert is_map(Object.get_by_id(object2.id).data["likes"])

	assert :ok == Mix.Tasks.Pleroma.Database.run(["fix_likes_collections"])

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert Enum.empty?(Object.get_by_id(object2.id).data["likes"])
	end
	end

	describe "ensure_expiration" do
	test "it adds to expiration old statuses" do
	activity1 = insert(:note_activity)

	{:ok, inserted_at, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
	activity2 = insert(:note_activity, %{inserted_at: inserted_at})

	%{id: activity_id3} = insert(:note_activity)

	expires_at = DateTime.add(DateTime.utc_now(), 60 * 61)

	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: activity_id3
	},
	scheduled_at: expires_at
	)

	Mix.Tasks.Pleroma.Database.run(["ensure_expiration"])

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity1.id},
	scheduled_at:
	activity1.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity2.id},
	scheduled_at:
	activity2.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity_id3},
	scheduled_at: expires_at
	)
	end
	end
	end
	diff --git a/test/pleroma/http_test.exs b/test/pleroma/http_test.exs
	index 7b6847cf9..e673e6591 100644
	--- a/test/pleroma/http_test.exs
	+++ b/test/pleroma/http_test.exs
	@@ -1,217 +1,217 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTPTest do
	- use ExUnit.Case, async: true
	+ use ExUnit.Case, async: false
	use Pleroma.Tests.Helpers

	import Tesla.Mock

	alias Pleroma.HTTP
	alias Pleroma.Utils.URIEncoding

	setup do
	mock(fn
	%{
	method: :get,
	url: "http://example.com/hello",
	headers: [{"content-type", "application/json"}]
	} ->
	json(%{"my" => "data"})

	%{method: :head, url: "http://example.com/hello"} ->
	%Tesla.Env{status: 200, body: ""}

	%{method: :get, url: "http://example.com/hello"} ->
	%Tesla.Env{status: 200, body: "hello"}

	%{method: :post, url: "http://example.com/world"} ->
	%Tesla.Env{status: 200, body: "world"}

	%{method: :get, url: "https://example.com/emoji/Pack%201/koronebless.png?foo=bar+baz"} ->
	%Tesla.Env{status: 200, body: "emoji data"}

	%{
	method: :get,
	url: "https://example.com/media/foo/bar%20!$&'()*+,;=/:%20@a%20%5Bbaz%5D.mp4"
	} ->
	%Tesla.Env{status: 200, body: "video data"}

	%{method: :get, url: "https://example.com/media/unicode%20%F0%9F%99%82%20.gif"} ->
	%Tesla.Env{status: 200, body: "unicode data"}

	%{
	method: :get,
	url:
	"https://i.guim.co.uk/img/media/1069ef13c447908272c4de94174cec2b6352cb2f/0_91_2000_1201/master/2000.jpg?width=1200&height=630&quality=85&auto=format&fit=crop&precrop=40:21,offset-x50,offset-y0&overlay-align=bottom%2Cleft&overlay-width=100p&overlay-base64=L2ltZy9zdGF0aWMvb3ZlcmxheXMvdGctb3BpbmlvbnMtYWdlLTIwMTkucG5n&enable=upscale&s=cba21427a73512fdc9863c486c03fdd8"
	} ->
	%Tesla.Env{status: 200, body: "Guardian image quirk"}

	%{
	method: :get,
	url:
	"https://i.guim.co.uk/emoji/Pack%201/koronebless.png?precrop=40:21,overlay-x0,overlay-y0&foo=bar+baz"
	} ->
	%Tesla.Env{status: 200, body: "Space in query with Guardian quirk"}

	%{
	method: :get,
	url:
	"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=accessKEY%2F20130721%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20130721T201207Z&X-Amz-Expires=86400&X-Amz-Signature=SIGNATURE&X-Amz-SignedHeaders=host"
	} ->
	%Tesla.Env{status: 200, body: "AWS S3 data"}
	end)

	:ok
	end

	describe "head/1" do
	test "returns successfully result" do
	assert HTTP.head("http://example.com/hello") == {:ok, %Tesla.Env{status: 200, body: ""}}
	end
	end

	describe "get/1" do
	test "returns successfully result" do
	assert HTTP.get("http://example.com/hello") == {
	:ok,
	%Tesla.Env{status: 200, body: "hello"}
	}
	end
	end

	describe "get/2 (with headers)" do
	test "returns successfully result for json content-type" do
	assert HTTP.get("http://example.com/hello", [{"content-type", "application/json"}]) ==
	{
	:ok,
	%Tesla.Env{
	status: 200,
	body: "{\"my\":\"data\"}",
	headers: [{"content-type", "application/json"}]
	}
	}
	end
	end

	describe "post/2" do
	test "returns successfully result" do
	assert HTTP.post("http://example.com/world", "") == {
	:ok,
	%Tesla.Env{status: 200, body: "world"}
	}
	end
	end

	test "URL encoding properly encodes URLs with spaces" do
	clear_config(:test_url_encoding, true)

	url_with_space = "https://example.com/emoji/Pack 1/koronebless.png?foo=bar baz"

	{:ok, result} = HTTP.get(url_with_space)

	assert result.status == 200

	properly_encoded_url = "https://example.com/emoji/Pack%201/koronebless.png?foo=bar+baz"

	{:ok, result} = HTTP.get(properly_encoded_url)

	assert result.status == 200

	url_with_reserved_chars = "https://example.com/media/foo/bar !$&'()*+,;=/: @a [baz].mp4"

	{:ok, result} = HTTP.get(url_with_reserved_chars)

	assert result.status == 200

	url_with_unicode = "https://example.com/media/unicode 🙂 .gif"

	{:ok, result} = HTTP.get(url_with_unicode)

	assert result.status == 200
	end

	test "decodes URL first by default" do
	clear_config(:test_url_encoding, true)

	normal_url = "https://example.com/media/file%20with%20space.jpg?name=a+space.jpg"

	result = URIEncoding.encode_url(normal_url)

	assert result == "https://example.com/media/file%20with%20space.jpg?name=a+space.jpg"
	end

	test "doesn't decode URL first when specified" do
	clear_config(:test_url_encoding, true)

	normal_url = "https://example.com/media/file%20with%20space.jpg"

	result = URIEncoding.encode_url(normal_url, bypass_decode: true)

	assert result == "https://example.com/media/file%2520with%2520space.jpg"
	end

	test "properly applies Guardian image query quirk" do
	clear_config(:test_url_encoding, true)

	url =
	"https://i.guim.co.uk/img/media/1069ef13c447908272c4de94174cec2b6352cb2f/0_91_2000_1201/master/2000.jpg?width=1200&height=630&quality=85&auto=format&fit=crop&precrop=40:21,offset-x50,offset-y0&overlay-align=bottom%2Cleft&overlay-width=100p&overlay-base64=L2ltZy9zdGF0aWMvb3ZlcmxheXMvdGctb3BpbmlvbnMtYWdlLTIwMTkucG5n&enable=upscale&s=cba21427a73512fdc9863c486c03fdd8"

	result = URIEncoding.encode_url(url)

	assert result == url

	{:ok, result_get} = HTTP.get(result)

	assert result_get.status == 200
	end

	test "properly encodes spaces as \"pluses\" in query when using quirks" do
	clear_config(:test_url_encoding, true)

	url =
	"https://i.guim.co.uk/emoji/Pack 1/koronebless.png?precrop=40:21,overlay-x0,overlay-y0&foo=bar baz"

	properly_encoded_url =
	"https://i.guim.co.uk/emoji/Pack%201/koronebless.png?precrop=40:21,overlay-x0,overlay-y0&foo=bar+baz"

	result = URIEncoding.encode_url(url)

	assert result == properly_encoded_url

	{:ok, result_get} = HTTP.get(result)

	assert result_get.status == 200
	end

	test "properly encode AWS S3 queries" do
	clear_config(:test_url_encoding, true)

	url =
	"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=accessKEY%2F20130721%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20130721T201207Z&X-Amz-Expires=86400&X-Amz-Signature=SIGNATURE&X-Amz-SignedHeaders=host"

	unencoded_url =
	"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=accessKEY/20130721/us-east-1/s3/aws4_request&X-Amz-Date=20130721T201207Z&X-Amz-Expires=86400&X-Amz-Signature=SIGNATURE&X-Amz-SignedHeaders=host"

	result = URIEncoding.encode_url(url)
	result_unencoded = URIEncoding.encode_url(unencoded_url)

	assert result == url
	assert result == result_unencoded

	{:ok, result_get} = HTTP.get(result)

	assert result_get.status == 200
	end

	test "preserves query key order" do
	clear_config(:test_url_encoding, true)

	url = "https://example.com/foo?hjkl=qwertz&xyz=abc&bar=baz"

	result = URIEncoding.encode_url(url)

	assert result == url
	end
	end
	diff --git a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	index 99522994a..c15967eee 100644
	--- a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	+++ b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	@@ -1,71 +1,71 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo.Migrations.AutolinkerToLinkifyTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	import Pleroma.Factory
	import Pleroma.Tests.Helpers
	alias Pleroma.ConfigDB

	setup_all do: require_migration("20200716195806_autolinker_to_linkify")

	test "change/0 converts auto_linker opts for Pleroma.Formatter", %{migration: migration} do
	autolinker_opts = [
	extra: true,
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "testing"
	]

	insert(:config, group: :auto_linker, key: :opts, value: autolinker_opts)

	migration.change()

	assert nil == ConfigDB.get_by_params(%{group: :auto_linker, key: :opts})

	%{value: new_opts} = ConfigDB.get_by_params(%{group: :pleroma, key: Pleroma.Formatter})

	assert Keyword.equal?(new_opts,
	class: false,
	extra: true,
	new_window: false,
	rel: "testing",
	strip_prefix: false
	)

	clear_config(Pleroma.Formatter, new_opts)
	assert new_opts == Pleroma.Config.get(Pleroma.Formatter)

	{text, _mentions, []} =
	Pleroma.Formatter.linkify(
	"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\n\nOmg will COVID finally end Black Friday???"
	)

	assert text ==
	"<a href=\"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\" rel=\"testing\">https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7</a>\n\nOmg will COVID finally end Black Friday???"
	end

	test "transform_opts/1 returns a list of compatible opts", %{migration: migration} do
	old_opts = [
	extra: true,
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "qqq"
	]

	expected_opts = [
	class: false,
	extra: true,
	new_window: false,
	rel: "qqq",
	strip_prefix: false
	]

	assert Keyword.equal?(migration.transform_opts(old_opts), expected_opts)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs b/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	index 8d2a6b4fa..270c650e0 100644
	--- a/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	@@ -1,155 +1,155 @@
	defmodule Pleroma.Web.ActivityPub.MRF.RemoteReportPolicyTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy

	setup do
	clear_config([:mrf_remote_report, :reject_all], false)
	end

	test "doesn't impact local report" do
	clear_config([:mrf_remote_report, :reject_anonymous], true)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "http://localhost:4001/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects anonymous report if `reject_anonymous: true`" do
	clear_config([:mrf_remote_report, :reject_anonymous], true)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves anonymous report if `reject_anonymous: false`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects report on third party if `reject_third_party: true`" do
	clear_config([:mrf_remote_report, :reject_third_party], true)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves report on first party if `reject_third_party: true`" do
	clear_config([:mrf_remote_report, :reject_third_party], true)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["http://localhost:4001/actor"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves report on third party if `reject_third_party: false`" do
	clear_config([:mrf_remote_report, :reject_third_party], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects empty message report if `reject_empty_message: true`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "rejects empty message report (\"\") if `reject_empty_message: true`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], true)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"],
	"content" => ""
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves empty message report if `reject_empty_message: false`" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "preserves anonymous, empty message report with all settings disabled" do
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/actor",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:ok, _} = RemoteReportPolicy.filter(activity)
	end

	test "reject remote report if `reject_all: true`" do
	clear_config([:mrf_remote_report, :reject_all], true)
	clear_config([:mrf_remote_report, :reject_anonymous], false)
	clear_config([:mrf_remote_report, :reject_empty_message], false)

	activity = %{
	"type" => "Flag",
	"actor" => "https://mastodon.social/users/Gargron",
	"content" => "Transphobia",
	"object" => ["https://mastodon.online/users/Gargron"]
	}

	assert {:reject, _} = RemoteReportPolicy.filter(activity)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/utils_test.exs b/test/pleroma/web/activity_pub/utils_test.exs
	index a48639c38..f162f3684 100644
	--- a/test/pleroma/web/activity_pub/utils_test.exs
	+++ b/test/pleroma/web/activity_pub/utils_test.exs
	@@ -1,747 +1,747 @@
	# 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.UtilsTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	describe "strip_report_status_data/1" do
	test "does not break on issues with the reported activities" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"
	post_id = activity.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => post_id}],
	content: content
	},
	%{}
	)

	res =
	res
	\|> Map.put("object", res["object"] ++ [nil, 1, 5, "123"])

	{:ok, activity} = Pleroma.Web.ActivityPub.ActivityPub.insert(res)

	[user_id, object \| _] = activity.data["object"]

	{:ok, stripped} = Utils.strip_report_status_data(activity)

	assert stripped.data["object"] == [user_id, object["id"]]
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object has tags as map" do
	object = %{
	"tag" => %{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not address actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	visibility: "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	describe "make_json_ld_header/1" do
	test "makes jsonld header" do
	assert Utils.make_json_ld_header() == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	test "includes language if specified" do
	assert Utils.make_json_ld_header(%{"language" => "pl"}) == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "pl"
	}
	]
	}
	end
	end

	describe "get_existing_votes" do
	test "fetches existing votes" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How do I pronounce LaTeX?",
	poll: %{
	options: ["laytekh", "lahtekh", "latex"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, votes, object} = CommonAPI.vote(object, other_user, [0, 1])
	assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
	end

	test "fetches only Create activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Are we living in a society?",
	poll: %{
	options: ["yes", "no"],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, [vote], object} = CommonAPI.vote(object, other_user, [0])
	{:ok, _activity} = CommonAPI.favorite(activity.id, user)
	[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
	assert fetched_vote.id == vote.id
	end
	end

	describe "update_follow_state_for_all/2" do
	test "updates the state of all Follow activities with the same actor and object" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

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

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

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "accept")

	assert refresh_record(follow_activity).data["state"] == "accept"
	assert refresh_record(follow_activity_two).data["state"] == "accept"
	end

	test "also updates the state of accepted follows" do
	user = insert(:user)
	follower = insert(:user)

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

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "reject"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

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

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

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "pending"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_element_in_object/3" do
	test "updates likes" do
	user = insert(:user)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	assert {:ok, updated_object} =
	Utils.update_element_in_object(
	"like",
	[user.ap_id],
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "add_like_to_object/2" do
	test "add actor to likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note)

	assert {:ok, updated_object} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1

	assert {:ok, updated_object2} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user2.ap_id}},
	updated_object
	)

	assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
	assert updated_object2.data["like_count"] == 2
	end
	end

	describe "remove_like_from_object/2" do
	test "removes ap_id from likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})

	assert {:ok, updated_object} =
	Utils.remove_like_from_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user2.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "get_existing_like/2" do
	test "fetches existing like" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)

	user = insert(:user)
	refute Utils.get_existing_like(user.ap_id, object)
	{:ok, like_activity} = CommonAPI.favorite(note_activity.id, user)

	assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
	end
	end

	describe "get_get_existing_announce/2" do
	test "returns nil if announce not found" do
	actor = insert(:user)
	refute Utils.get_existing_announce(actor.ap_id, %{data: %{"id" => "test"}})
	end

	test "fetches existing announce" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)
	actor = insert(:user)

	{:ok, announce} = CommonAPI.repeat(note_activity.id, actor)
	assert Utils.get_existing_announce(actor.ap_id, object) == announce
	end
	end

	describe "fetch_latest_block/2" do
	test "fetches last block activities" do
	user1 = insert(:user)
	user2 = insert(:user)

	assert {:ok, %Activity{} = _} = CommonAPI.block(user2, user1)
	assert {:ok, %Activity{} = _} = CommonAPI.block(user2, user1)
	assert {:ok, %Activity{} = activity} = CommonAPI.block(user2, user1)

	assert Utils.fetch_latest_block(user1, user2) == activity
	end
	end

	describe "recipient_in_message/3" do
	test "returns true when recipient in `to`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"to" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"to" => [recipient.ap_id], "cc" => ""}
	)
	end

	test "returns true when recipient in `cc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"cc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"cc" => [recipient.ap_id], "to" => ""}
	)
	end

	test "returns true when recipient in `bto`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bto" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bcc" => "", "bto" => [recipient.ap_id]}
	)
	end

	test "returns true when recipient in `bcc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bcc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bto" => "", "bcc" => [recipient.ap_id]}
	)
	end

	test "returns true when message without addresses fields" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bccc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"btod" => "", "bccc" => [recipient.ap_id]}
	)
	end

	test "returns false" do
	recipient = insert(:user)
	actor = insert(:user)
	refute Utils.recipient_in_message(recipient, actor, %{"to" => "ap_id"})
	end
	end

	describe "lazy_put_activity_defaults/2" do
	test "returns map with id and published data" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	res = Utils.lazy_put_activity_defaults(%{"context" => object.data["id"]})
	assert res["context"] == object.data["id"]
	assert res["id"]
	assert res["published"]
	end

	test "returns map with fake id and published data" do
	assert %{
	"context" => "pleroma:fakecontext",
	"id" => "pleroma:fakeid",
	"published" => _
	} = Utils.lazy_put_activity_defaults(%{}, true)
	end

	test "returns activity data with object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)

	res =
	Utils.lazy_put_activity_defaults(%{
	"context" => object.data["id"],
	"object" => %{}
	})

	assert res["context"] == object.data["id"]
	assert res["id"]
	assert res["published"]
	assert res["object"]["id"]
	assert res["object"]["published"]
	assert res["object"]["context"] == object.data["id"]
	end
	end

	describe "make_flag_data" do
	test "returns empty map when params is invalid" do
	assert Utils.make_flag_data(%{}, %{}) == %{}
	end

	test "returns map with Flag object" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	object_ap_id = activity.object.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => activity.data["id"]}],
	content: content
	},
	%{}
	)

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

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end

	test "returns map with Flag object with a non-Create Activity" do
	reporter = insert(:user)
	posting_account = insert(:user)
	target_account = insert(:user)

	{:ok, activity} = CommonAPI.post(posting_account, %{status: "foobar"})
	{:ok, like} = CommonAPI.favorite(activity.id, target_account)
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	object_ap_id = activity.object.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => like.data["id"]}],
	content: content
	},
	%{}
	)

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

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end
	end

	describe "add_announce_to_object/2" do
	test "adds actor to announcement" do
	user = insert(:user)
	object = insert(:note)

	activity =
	insert(:note_activity,
	data: %{
	"actor" => user.ap_id,
	"cc" => [Pleroma.Constants.as_public()]
	}
	)

	assert {:ok, updated_object} = Utils.add_announce_to_object(activity, object)
	assert updated_object.data["announcements"] == [user.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "remove_announce_from_object/2" do
	test "removes actor from announcements" do
	user = insert(:user)
	user2 = insert(:user)

	object =
	insert(:note,
	data: %{"announcements" => [user.ap_id, user2.ap_id], "announcement_count" => 2}
	)

	activity = insert(:note_activity, data: %{"actor" => user.ap_id})

	assert {:ok, updated_object} = Utils.remove_announce_from_object(activity, object)
	assert updated_object.data["announcements"] == [user2.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "get_cached_emoji_reactions/1" do
	test "returns the normalized data or an empty list" do
	object = insert(:note)
	assert Utils.get_cached_emoji_reactions(object) == []

	object = insert(:note, data: %{"reactions" => [["x", ["lain"]]]})
	assert Utils.get_cached_emoji_reactions(object) == [["x", ["lain"], nil]]

	object = insert(:note, data: %{"reactions" => %{}})
	assert Utils.get_cached_emoji_reactions(object) == []
	end
	end

	describe "add_emoji_reaction_to_object/1" do
	test "works with legacy 2-tuple format" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	_activity = insert(:note_activity, user: user, note: note)

	Utils.add_emoji_reaction_to_object(
	%Activity{data: %{"content" => "😿", "actor" => third_user.ap_id}},
	note
	)
	end
	end

	describe "maybe_anonymize_reporter/1" do
	setup do
	reporter = insert(:user)
	report = %{"actor" => reporter.ap_id}

	%{
	placeholder: insert(:user),
	reporter: reporter,
	report: report
	}
	end

	test "anonymize when configured correctly", %{
	placeholder: placeholder,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	assert %{"actor" => placeholder.ap_id} == Utils.maybe_anonymize_reporter(report)
	end

	test "anonymize Activity", %{
	placeholder: placeholder,
	reporter: reporter,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)
	report_activity = %Activity{actor: reporter, data: report}
	anon_id = placeholder.ap_id

	assert %Activity{actor: ^anon_id, data: %{"actor" => ^anon_id}} =
	Utils.maybe_anonymize_reporter(report_activity)
	end

	test "do not anonymize when disabled", %{
	placeholder: placeholder,
	reporter: reporter,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], false)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	assert %{"actor" => reporter.ap_id} == Utils.maybe_anonymize_reporter(report)
	end

	test "do not anonymize when user does not exist", %{
	placeholder: placeholder,
	reporter: reporter,
	report: report
	} do
	clear_config([:activitypub, :anonymize_reporter], true)

	clear_config(
	[:activitypub, :anonymize_reporter_local_nickname],
	placeholder.nickname <> "MewMew"
	)

	assert %{"actor" => reporter.ap_id} == Utils.maybe_anonymize_reporter(report)
	end

	test "do not anonymize when user is not local", %{
	reporter: reporter,
	report: report
	} do
	placeholder = insert(:user, local: false)
	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	assert %{"actor" => reporter.ap_id} == Utils.maybe_anonymize_reporter(report)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/views/user_view_test.exs b/test/pleroma/web/activity_pub/views/user_view_test.exs
	index 7ac5f7c0f..a3f807ca9 100644
	--- a/test/pleroma/web/activity_pub/views/user_view_test.exs
	+++ b/test/pleroma/web/activity_pub/views/user_view_test.exs
	@@ -1,224 +1,224 @@
	# 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.UserViewTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.CommonAPI

	test "Renders a user, including the public key" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["preferredUsername"] == user.nickname

	assert String.contains?(result["publicKey"]["publicKeyPem"], "BEGIN PUBLIC KEY")
	end

	test "Renders profile fields" do
	fields = [
	%{"name" => "foo", "value" => "bar"}
	]

	{:ok, user} =
	insert(:user)
	\|> User.update_changeset(%{fields: fields})
	\|> User.update_and_set_cache()

	assert %{
	"attachment" => [%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"}]
	} = UserView.render("user.json", %{user: user})
	end

	test "Renders with emoji tags" do
	user = insert(:user, emoji: %{"bib" => "/test"})

	assert %{
	"tag" => [
	%{
	"icon" => %{"type" => "Image", "url" => "/test"},
	"id" => "/test",
	"name" => ":bib:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	} = UserView.render("user.json", %{user: user})
	end

	test "Does not add an avatar image if the user hasn't set one" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})
	refute result["icon"]
	refute result["image"]

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	banner: %{"url" => [%{"href" => "https://somebanner"}]}
	)

	result = UserView.render("user.json", %{user: user})
	assert result["icon"]["url"] == "https://someurl"
	assert result["image"]["url"] == "https://somebanner"

	refute result["icon"]["name"]
	refute result["image"]["name"]
	end

	test "Avatar has a description if the user set one" do
	user =
	insert(:user,
	avatar: %{
	"url" => [%{"href" => "https://someurl"}],
	"name" => "a drawing of pleroma-tan using pleroma groups"
	}
	)

	result = UserView.render("user.json", %{user: user})

	assert result["icon"]["name"] == "a drawing of pleroma-tan using pleroma groups"
	end

	test "renders an invisible user with the invisible property set to true" do
	user = insert(:user, invisible: true)

	assert %{"invisible" => true} = UserView.render("service.json", %{user: user})
	end

	test "service has a few essential fields" do
	user = insert(:user)
	result = UserView.render("service.json", %{user: user})
	assert result["id"]
	assert result["type"] == "Application"
	assert result["inbox"]
	assert result["outbox"]
	end

	test "renders AKAs" do
	akas = ["https://i.tusooa.xyz/users/test-pleroma"]
	user = insert(:user, also_known_as: akas)
	assert %{"alsoKnownAs" => ^akas} = UserView.render("user.json", %{user: user})
	end

	test "renders full nickname" do
	clear_config([Pleroma.Web.WebFinger, :domain], "plemora.dev")

	user = insert(:user, nickname: "user")
	assert %{"webfinger" => "acct:user@plemora.dev"} = UserView.render("user.json", %{user: user})
	end

	describe "endpoints" do
	test "local users have a usable endpoints structure" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id

	%{
	"sharedInbox" => _,
	"oauthAuthorizationEndpoint" => _,
	"oauthRegistrationEndpoint" => _,
	"oauthTokenEndpoint" => _
	} = result["endpoints"]
	end

	test "remote users have an empty endpoints structure" do
	user = insert(:user, local: false)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["endpoints"] == %{}
	end

	test "instance users do not expose oAuth endpoints" do
	user = insert(:user, nickname: nil, local: true)

	result = UserView.render("user.json", %{user: user})

	refute result["endpoints"]["oauthAuthorizationEndpoint"]
	refute result["endpoints"]["oauthRegistrationEndpoint"]
	refute result["endpoints"]["oauthTokenEndpoint"]
	end
	end

	describe "followers" do
	test "sets totalItems to zero when followers are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: true, hide_followers: true})
	refute UserView.render("followers.json", %{user: user}) \|> Map.has_key?("totalItems")
	end

	test "sets correct totalItems when followers are hidden but the follower counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: false, hide_followers: true})
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	end

	test "does not hide follower items based on `hide_follows`" do
	user = insert(:user)
	follower = insert(:user)
	{:ok, user, _follower, _activity} = CommonAPI.follow(user, follower)

	user = Map.merge(user, %{hide_followers: false, hide_follows: true})
	follower_ap_id = follower.ap_id

	assert %{"first" => %{"orderedItems" => [^follower_ap_id]}} =
	UserView.render("followers.json", %{user: user})
	end
	end

	describe "following" do
	test "sets totalItems to zero when follows are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: true, hide_follows: true})
	assert %{"totalItems" => 0} = UserView.render("following.json", %{user: user})
	end

	test "sets correct totalItems when follows are hidden but the follow counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: false, hide_follows: true})
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	end
	end

	describe "acceptsChatMessages" do
	test "it returns this value if it is set" do
	true_user = insert(:user, accepts_chat_messages: true)
	false_user = insert(:user, accepts_chat_messages: false)
	nil_user = insert(:user, accepts_chat_messages: nil)

	assert %{"capabilities" => %{"acceptsChatMessages" => true}} =
	UserView.render("user.json", user: true_user)

	assert %{"capabilities" => %{"acceptsChatMessages" => false}} =
	UserView.render("user.json", user: false_user)

	refute Map.has_key?(
	UserView.render("user.json", user: nil_user)["capabilities"],
	"acceptsChatMessages"
	)
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	index c78c03aba..8c3682798 100644
	--- a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	@@ -1,90 +1,95 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatMessageReferenceViewTest do
	alias Pleroma.NullCache
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView

	import Mox
	import Pleroma.Factory

	+ setup do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+ :ok
	+ end
	+
	setup do: clear_config([:rich_media, :enabled], true)

	test "it displays a chat message" do
	user = insert(:user)
	recipient = insert(:user)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

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

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

	{:ok, activity} =
	CommonAPI.post_chat_message(user, recipient, "kippis :firefox:", idempotency_key: "123")

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

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

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	id = cm_ref.id

	Pleroma.CachexMock
	\|> stub(:get, fn
	:chat_message_id_idempotency_key_cache, ^id -> {:ok, "123"}
	cache, key -> NullCache.get(cache, key)
	end)
	\|> stub(:fetch, fn :rich_media_cache, _, _ -> {:ok, {:ok, %{}}} end)

	chat_message = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message[:id] == cm_ref.id
	assert chat_message[:content] == "kippis :firefox:"
	assert chat_message[:account_id] == user.id
	assert chat_message[:chat_id]
	assert chat_message[:created_at]
	assert chat_message[:unread] == false
	assert match?([%{shortcode: "firefox"}], chat_message[:emojis])
	assert chat_message[:idempotency_key] == "123"

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

	{:ok, activity} =
	CommonAPI.post_chat_message(recipient, user, "gkgkgk https://example.com/ogp",
	media_id: upload.id
	)

	ObanHelpers.perform_all()

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

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	chat_message_two = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message_two[:id] == cm_ref.id
	assert chat_message_two[:content] == object.data["content"]
	assert chat_message_two[:account_id] == recipient.id
	assert chat_message_two[:chat_id] == chat_message[:chat_id]
	assert chat_message_two[:attachment]
	assert chat_message_two[:unread] == true
	assert chat_message_two[:card]
	end
	end
	diff --git a/test/pleroma/web/rich_media/card_test.exs b/test/pleroma/web/rich_media/card_test.exs
	index c69f85323..723446c86 100644
	--- a/test/pleroma/web/rich_media/card_test.exs
	+++ b/test/pleroma/web/rich_media/card_test.exs
	@@ -1,105 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.CardTest do
	use Oban.Testing, repo: Pleroma.Repo
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Card
	alias Pleroma.Workers.RichMediaWorker

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

	setup do: clear_config([:rich_media, :enabled], true)

	test "crawls URL in activity" do
	user = insert(:user)

	url = "https://example.com/ogp"
	url_hash = Card.url_to_hash(url)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](#{url})",
	content_type: "text/markdown"
	})

	Pleroma.Web.ActivityPub.ActivityPubMock
	\|> expect(:stream_out, fn ^activity -> nil end)

	assert_enqueued(
	worker: RichMediaWorker,
	args: %{"url" => url, "activity_id" => activity.id}
	)

	ObanHelpers.perform_all()

	assert %Card{url_hash: ^url_hash, fields: _} = Card.get_by_activity(activity)
	end

	test "recrawls URLs on status edits/updates" do
	original_url = "https://google.com/"
	original_url_hash = Card.url_to_hash(original_url)
	updated_url = "https://yahoo.com/"
	updated_url_hash = Card.url_to_hash(updated_url)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "I like this site #{original_url}"})

	# Force a backfill
	Card.get_by_activity(activity)
	ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^original_url_hash, fields: _},
	Card.get_by_activity(activity)
	)

	{:ok, _} = CommonAPI.update(activity, user, %{status: "I like this site #{updated_url}"})

	activity = Pleroma.Activity.get_by_id(activity.id)

	# Force a backfill
	Card.get_by_activity(activity)
	ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^updated_url_hash, fields: _},
	Card.get_by_activity(activity)
	)
	end

	test "refuses to crawl URL in activity from ignored host/domain" do
	clear_config([:rich_media, :ignore_hosts], ["example.com"])

	user = insert(:user)

	url = "https://example.com/ogp"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](#{url})",
	content_type: "text/markdown"
	})

	refute_enqueued(
	worker: RichMediaWorker,
	args: %{"url" => url, "activity_id" => activity.id}
	)
	end
	end
	diff --git a/test/pleroma/web/web_finger_test.exs b/test/pleroma/web/web_finger_test.exs
	index eb03c736e..da10abdd2 100644
	--- a/test/pleroma/web/web_finger_test.exs
	+++ b/test/pleroma/web/web_finger_test.exs
	@@ -1,307 +1,308 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFingerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	alias Pleroma.Web.WebFinger
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "host meta" do
	test "returns a link to the xml lrdd" do
	host_info = WebFinger.host_meta()

	assert String.contains?(host_info, Pleroma.Web.Endpoint.url())
	end
	end

	describe "incoming webfinger request" do
	test "works for fqns" do
	user = insert(:user)

	{:ok, result} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "XML")

	assert is_binary(result)
	end

	test "works for ap_ids" do
	user = insert(:user)

	{:ok, result} = WebFinger.webfinger(user.ap_id, "XML")
	assert is_binary(result)
	end
	end

	test "requires exact match for Endpoint host or WebFinger domain" do
	clear_config([Pleroma.Web.WebFinger, :domain], "pleroma.dev")
	user = insert(:user)

	assert {:error, "Couldn't find user"} ==
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}xxxx", "JSON")

	assert {:error, "Couldn't find user"} ==
	WebFinger.webfinger("#{user.nickname}@pleroma.devxxxx", "JSON")

	assert {:ok, _} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "JSON")

	assert {:ok, _} =
	WebFinger.webfinger("#{user.nickname}@pleroma.dev", "JSON")
	end

	describe "fingering" do
	test "returns error for nonsensical input" do
	assert {:error, _} = WebFinger.finger("bliblablu")
	assert {:error, _} = WebFinger.finger("pleroma.social")
	end

	test "returns error when there is no content-type header" do
	Tesla.Mock.mock(fn
	%{url: "https://social.heldscal.la/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/social.heldscal.la_host_meta")
	}}

	%{
	url:
	"https://social.heldscal.la/.well-known/webfinger?resource=acct:invalid_content@social.heldscal.la"
	} ->
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end)

	user = "invalid_content@social.heldscal.la"
	assert {:error, {:content_type, nil}} = WebFinger.finger(user)
	end

	test "returns error when fails parse xml or json" do
	user = "invalid_content@social.heldscal.la"
	assert {:error, %Jason.DecodeError{}} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI for an ActivityPub user" do
	user = "framasoft@framatube.org"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "it works for AP-only user" do
	user = "kpherox@mstdn.jp"

	{:ok, data} = WebFinger.finger(user)

	assert data["magic_key"] == nil
	assert data["salmon"] == nil

	assert data["topic"] == nil
	assert data["subject"] == "acct:kPherox@mstdn.jp"
	assert data["ap_id"] == "https://mstdn.jp/users/kPherox"
	assert data["subscribe_address"] == "https://mstdn.jp/authorize_interaction?acct={uri}"
	end

	test "it gets the xrd endpoint" do
	{:ok, template} = WebFinger.find_lrdd_template("social.heldscal.la")

	assert template == "https://social.heldscal.la/.well-known/webfinger?resource={uri}"
	end

	test "it gets the xrd endpoint for hubzilla" do
	{:ok, template} = WebFinger.find_lrdd_template("macgirvin.com")

	assert template == "https://macgirvin.com/xrd/?uri={uri}"
	end

	test "it gets the xrd endpoint for statusnet" do
	{:ok, template} = WebFinger.find_lrdd_template("status.alpicola.com")

	assert template == "https://status.alpicola.com/main/xrd?uri={uri}"
	end

	test "it works with idna domains as nickname" do
	nickname = "lain@" <> to_string(:idna.encode("zetsubou.みんな"))

	{:ok, _data} = WebFinger.finger(nickname)
	end

	test "it works with idna domains as link" do
	ap_id = "https://" <> to_string(:idna.encode("zetsubou.みんな")) <> "/users/lain"
	{:ok, _data} = WebFinger.finger(ap_id)
	end

	test "respects json content-type" do
	Tesla.Mock.mock(fn
	%{
	url:
	"https://mastodon.social/.well-known/webfinger?resource=acct:emelie@mastodon.social"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/webfinger_emelie.json"),
	headers: [{"content-type", "application/jrd+json"}]
	}}

	%{url: "https://mastodon.social/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mastodon.social_host_meta")
	}}
	end)

	{:ok, _data} = WebFinger.finger("emelie@mastodon.social")
	end

	test "respects xml content-type" do
	Tesla.Mock.mock(fn
	%{
	url: "https://pawoo.net/.well-known/webfinger?resource=acct:pekorino@pawoo.net"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___pawoo.net_users_pekorino.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}

	%{url: "https://pawoo.net/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/pawoo.net_host_meta")
	}}
	end)

	{:ok, _data} = WebFinger.finger("pekorino@pawoo.net")
	end

	test "refuses to process XML remote entities" do
	Tesla.Mock.mock(fn
	%{
	url: "https://pawoo.net/.well-known/webfinger?resource=acct:pekorino@pawoo.net"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/xml_external_entities.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}

	%{url: "https://pawoo.net/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/pawoo.net_host_meta")
	}}
	end)

	assert :error = WebFinger.finger("pekorino@pawoo.net")
	end

	test "prevents spoofing" do
	Tesla.Mock.mock(fn
	%{
	url: "https://gleasonator.com/.well-known/webfinger?resource=acct:alex@gleasonator.com"
	} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/webfinger_spoof.json"),
	headers: [{"content-type", "application/jrd+json"}]
	}}

	%{url: "https://gleasonator.com/.well-known/host-meta"} ->
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/gleasonator.com_host_meta")
	}}

	%{url: "https://whitehouse.gov/.well-known/webfinger?resource=acct:trump@whitehouse.gov"} ->
	{:ok, %Tesla.Env{status: 404}}
	end)

	{:error, _data} = WebFinger.finger("alex@gleasonator.com")
	end

	test "prevents forgeries" do
	Tesla.Mock.mock(fn
	%{
	url:
	"https://fba.ryona.agency/.well-known/webfinger?resource=acct:graf@fba.ryona.agency"
	} ->
	fake_webfinger =
	File.read!("test/fixtures/webfinger/graf-imposter-webfinger.json") \|> Jason.decode!()

	Tesla.Mock.json(fake_webfinger)

	%{url: url}
	when url in [
	"https://poa.st/.well-known/webfinger?resource=acct:graf@poa.st",
	"https://fba.ryona.agency/.well-known/host-meta"
	] ->
	{:ok, %Tesla.Env{status: 404}}
	end)

	assert {:error, _} = WebFinger.finger("graf@fba.ryona.agency")
	end

	test "prevents forgeries even when the spoofed subject exists on the target domain" do
	Tesla.Mock.mock(fn
	%{url: url}
	when url in [
	"https://attacker.example/.well-known/host-meta",
	"https://victim.example/.well-known/host-meta"
	] ->
	{:ok, %Tesla.Env{status: 404}}

	%{
	url:
	"https://attacker.example/.well-known/webfinger?resource=acct:alice@attacker.example"
	} ->
	Tesla.Mock.json(%{
	"subject" => "acct:alice@victim.example",
	"links" => [
	%{
	"rel" => "self",
	"type" => "application/activity+json",
	"href" => "https://attacker.example/users/alice"
	}
	]
	})

	%{url: "https://victim.example/.well-known/webfinger?resource=acct:alice@victim.example"} ->
	Tesla.Mock.json(%{
	"subject" => "acct:alice@victim.example",
	"links" => [
	%{
	"rel" => "self",
	"type" => "application/activity+json",
	"href" => "https://victim.example/users/alice"
	}
	]
	})
	end)

	assert {:error, _} = WebFinger.finger("alice@attacker.example")
	end

	test "works for correctly set up split-domain instances implementing host-meta redirect" do
	{:ok, _data} = WebFinger.finger("a@pleroma.example")
	{:ok, _data} = WebFinger.finger("a@sub.pleroma.example")
	end

	test "works for correctly set up split-domain instances without host-meta redirect" do
	{:ok, _data} = WebFinger.finger("a@mastodon.example")
	{:ok, _data} = WebFinger.finger("a@sub.mastodon.example")
	end
	end
	end
	diff --git a/test/pleroma/workers/publisher_worker_test.exs b/test/pleroma/workers/publisher_worker_test.exs
	index ca432d9bf..4519864a5 100644
	--- a/test/pleroma/workers/publisher_worker_test.exs
	+++ b/test/pleroma/workers/publisher_worker_test.exs
	@@ -1,123 +1,123 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.PublisherWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import Mock

	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator

	describe "Oban job priority:" do
	setup do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "Regrettable post"})
	object = Object.normalize(post, fetch: false)
	{:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
	{:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)

	%{
	post: post,
	delete: delete
	}
	end

	test "Deletions are lower priority", %{delete: delete} do
	assert {:ok, %Oban.Job{priority: 3}} = Federator.publish(delete)
	end

	test "Creates are normal priority", %{post: post} do
	assert {:ok, %Oban.Job{priority: 0}} = Federator.publish(post)
	end
	end

	describe "Server reachability:" do
	setup do
	user = insert(:user)
	remote_user = insert(:user, local: false, inbox: "https://example.com/inbox")
	{:ok, _, _} = Pleroma.User.follow(remote_user, user)
	{:ok, activity} = CommonAPI.post(user, %{status: "Test post"})

	%{
	user: user,
	remote_user: remote_user,
	activity: activity
	}
	end

	test "marks server as unreachable only on final failure", %{activity: activity} do
	with_mock Pleroma.Web.Federator,
	perform: fn :publish_one, _params -> {:error, :connection_error} end do
	# First attempt
	job = %Oban.Job{
	args: %{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "https://example.com/inbox",
	"activity_id" => activity.id
	}
	},
	attempt: 1,
	max_attempts: 5
	}

	assert {:error, :connection_error} = Pleroma.Workers.PublisherWorker.perform(job)
	assert Instances.reachable?("https://example.com/inbox")

	# Final attempt
	job = %{job \| attempt: 5}
	assert {:error, :connection_error} = Pleroma.Workers.PublisherWorker.perform(job)
	refute Instances.reachable?("https://example.com/inbox")
	end
	end

	test "does not mark server as unreachable on successful publish", %{activity: activity} do
	with_mock Pleroma.Web.Federator,
	perform: fn :publish_one, _params -> {:ok, %{status: 200}} end do
	job = %Oban.Job{
	args: %{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "https://example.com/inbox",
	"activity_id" => activity.id
	}
	},
	attempt: 1,
	max_attempts: 5
	}

	assert :ok = Pleroma.Workers.PublisherWorker.perform(job)
	assert Instances.reachable?("https://example.com/inbox")
	end
	end

	test "cancels job if server is unreachable", %{activity: activity} do
	# First mark the server as unreachable
	Instances.set_unreachable("https://example.com/inbox")
	refute Instances.reachable?("https://example.com/inbox")

	job = %Oban.Job{
	args: %{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "https://example.com/inbox",
	"activity_id" => activity.id
	}
	},
	attempt: 1,
	max_attempts: 5
	}

	assert {:cancel, :unreachable} = Pleroma.Workers.PublisherWorker.perform(job)
	end
	end
	end
	diff --git a/test/pleroma/workers/reachability_worker_test.exs b/test/pleroma/workers/reachability_worker_test.exs
	index 4854aff77..c641ccf65 100644
	--- a/test/pleroma/workers/reachability_worker_test.exs
	+++ b/test/pleroma/workers/reachability_worker_test.exs
	@@ -1,226 +1,226 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.ReachabilityWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Mock

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Workers.ReachabilityWorker

	setup do
	ObanHelpers.wipe_all()
	:ok
	end

	describe "progressive backoff phases" do
	test "starts with phase_1min and progresses through phases on failure" do
	domain = "example.com"

	with_mocks([
	{Pleroma.HTTP, [], [get: fn _ -> {:error, :timeout} end]},
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	# Start with phase_1min
	job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 1}
	}

	# First attempt fails
	assert {:error, :timeout} = ReachabilityWorker.perform(job)

	# Should schedule retry for phase_1min (attempt 2)
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == "phase_1min"
	assert retry_job.args["attempt"] == 2

	# Clear jobs and simulate second attempt failure
	ObanHelpers.wipe_all()

	retry_job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 2}
	}

	assert {:error, :timeout} = ReachabilityWorker.perform(retry_job)

	# Should schedule retry for phase_1min (attempt 3)
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == "phase_1min"
	assert retry_job.args["attempt"] == 3

	# Clear jobs and simulate third attempt failure (final attempt for phase_1min)
	ObanHelpers.wipe_all()

	retry_job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 3}
	}

	assert {:error, :timeout} = ReachabilityWorker.perform(retry_job)

	# Should schedule retry for phase_1min (attempt 4)
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == "phase_1min"
	assert retry_job.args["attempt"] == 4

	# Clear jobs and simulate fourth attempt failure (final attempt for phase_1min)
	ObanHelpers.wipe_all()

	retry_job = %Oban.Job{
	args: %{"domain" => domain, "phase" => "phase_1min", "attempt" => 4}
	}

	assert {:error, :timeout} = ReachabilityWorker.perform(retry_job)

	# Should schedule next phase (phase_15min)
	next_phase_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_phase_jobs) == 1
	[next_phase_job] = next_phase_jobs
	assert next_phase_job.args["phase"] == "phase_15min"
	assert next_phase_job.args["attempt"] == 1
	end
	end

	test "progresses through all phases correctly" do
	domain = "example.com"

	with_mocks([
	{Pleroma.HTTP, [], [get: fn _ -> {:error, :timeout} end]},
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	# Simulate all phases failing
	phases = ["phase_1min", "phase_15min", "phase_1hour", "phase_8hour", "phase_24hour"]

	Enum.each(phases, fn phase ->
	{_interval, max_attempts, next_phase} = get_phase_config(phase)

	# Simulate all attempts failing for this phase
	Enum.each(1..max_attempts, fn attempt ->
	job = %Oban.Job{args: %{"domain" => domain, "phase" => phase, "attempt" => attempt}}
	assert {:error, :timeout} = ReachabilityWorker.perform(job)

	if attempt < max_attempts do
	# Should schedule retry for same phase
	retry_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(retry_jobs) == 1
	[retry_job] = retry_jobs
	assert retry_job.args["phase"] == phase
	assert retry_job.args["attempt"] == attempt + 1
	ObanHelpers.wipe_all()
	else
	# Should schedule next phase (except for final phase)
	if next_phase != "final" do
	next_phase_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_phase_jobs) == 1
	[next_phase_job] = next_phase_jobs
	assert next_phase_job.args["phase"] == next_phase
	assert next_phase_job.args["attempt"] == 1
	ObanHelpers.wipe_all()
	else
	# Final phase - no more jobs should be scheduled
	next_phase_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_phase_jobs) == 0
	end
	end
	end)
	end)
	end
	end

	test "succeeds and stops progression when instance becomes reachable" do
	domain = "example.com"

	with_mocks([
	{Pleroma.HTTP, [], [get: fn _ -> {:ok, %{status: 200}} end]},
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	job = %Oban.Job{args: %{"domain" => domain, "phase" => "phase_1hour", "attempt" => 2}}

	# Should succeed and not schedule any more jobs
	assert :ok = ReachabilityWorker.perform(job)

	# Verify set_reachable was called
	assert_called(Pleroma.Instances.set_reachable("https://#{domain}"))

	# No more jobs should be scheduled
	next_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(next_jobs) == 0
	end
	end

	test "enforces uniqueness per domain using Oban's conflict detection" do
	domain = "example.com"

	# Insert first job for the domain
	job1 =
	%{
	"domain" => domain,
	"phase" => "phase_1min",
	"attempt" => 1
	}
	\|> ReachabilityWorker.new()
	\|> Oban.insert()

	assert {:ok, _} = job1

	# Try to insert a second job for the same domain with different phase/attempt
	job2 =
	%{
	"domain" => domain,
	"phase" => "phase_15min",
	"attempt" => 1
	}
	\|> ReachabilityWorker.new()
	\|> Oban.insert()

	# Should fail due to uniqueness constraint (conflict)
	assert {:ok, %Oban.Job{conflict?: true}} = job2

	# Verify only one job exists for this domain
	jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(jobs) == 1
	[existing_job] = jobs
	assert existing_job.args["domain"] == domain
	assert existing_job.args["phase"] == "phase_1min"
	end

	test "handles new jobs with only domain argument and transitions them to the first phase" do
	domain = "legacy.example.com"

	with_mocks([
	{Pleroma.Instances, [], [set_reachable: fn _ -> :ok end]}
	]) do
	# Create a job with only domain (legacy format)
	job = %Oban.Job{
	args: %{"domain" => domain}
	}

	# Should reschedule with phase_1min and attempt 1
	assert :ok = ReachabilityWorker.perform(job)

	# Check that a new job was scheduled with the correct format
	scheduled_jobs = all_enqueued(worker: ReachabilityWorker)
	assert length(scheduled_jobs) == 1
	[scheduled_job] = scheduled_jobs
	assert scheduled_job.args["domain"] == domain
	assert scheduled_job.args["phase"] == "phase_1min"
	assert scheduled_job.args["attempt"] == 1
	end
	end
	end

	defp get_phase_config("phase_1min"), do: {1, 4, "phase_15min"}
	defp get_phase_config("phase_15min"), do: {15, 4, "phase_1hour"}
	defp get_phase_config("phase_1hour"), do: {60, 4, "phase_8hour"}
	defp get_phase_config("phase_8hour"), do: {480, 4, "phase_24hour"}
	defp get_phase_config("phase_24hour"), do: {1440, 4, "final"}
	defp get_phase_config("final"), do: {nil, 0, nil}
	end
	diff --git a/test/pleroma/workers/receiver_worker_test.exs b/test/pleroma/workers/receiver_worker_test.exs
	index 7f4789f91..12abc1a27 100644
	--- a/test/pleroma/workers/receiver_worker_test.exs
	+++ b/test/pleroma/workers/receiver_worker_test.exs
	@@ -1,305 +1,305 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.ReceiverWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.ReceiverWorker

	test "it does not retry MRF reject" do
	params = insert(:note).data

	with_mock Pleroma.Web.ActivityPub.Transmogrifier,
	handle_incoming: fn _ -> {:reject, "MRF"} end do
	assert {:cancel, {:reject, "MRF"}} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end

	test "it does not retry ObjectValidator reject" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", Pleroma.Web.ActivityPub.Utils.generate_activity_id())
	\|> Map.put("object", %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id()
	})

	with_mock Pleroma.Web.ActivityPub.ObjectValidator, [:passthrough],
	validate: fn _, _ -> {:error, %Ecto.Changeset{}} end do
	assert {:cancel, {:error, %Ecto.Changeset{}}} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end
	end

	test "it does not retry duplicates" do
	params = insert(:note_activity).data

	assert {:cancel, :already_present} =
	ReceiverWorker.perform(%Oban.Job{
	args: %{"op" => "incoming_ap_doc", "params" => params}
	})
	end

	describe "cancels on a failed user fetch" do
	setup do
	Tesla.Mock.mock(fn
	%{url: "https://springfield.social/users/bart"} ->
	%Tesla.Env{
	status: 403,
	body: ""
	}

	%{url: "https://springfield.social/users/troymcclure"} ->
	%Tesla.Env{
	status: 404,
	body: ""
	}

	%{url: "https://springfield.social/users/hankscorpio"} ->
	%Tesla.Env{
	status: 410,
	body: ""
	}
	end)
	end

	test "when request returns a 403" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/bart")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:error, :forbidden}} = ReceiverWorker.perform(oban_job)
	end

	test "when request returns a 404" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/troymcclure")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:error, :not_found}} = ReceiverWorker.perform(oban_job)
	end

	test "when request returns a 410" do
	params =
	insert(:note_activity).data
	\|> Map.put("actor", "https://springfield.social/users/hankscorpio")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:error, :not_found}} = ReceiverWorker.perform(oban_job)
	end

	test "when user account is disabled" do
	user = insert(:user)

	fake_activity = URI.parse(user.ap_id) \|> Map.put(:path, "/fake-activity") \|> to_string

	params =
	insert(:note_activity, user: user).data
	\|> Map.put("id", fake_activity)

	{:ok, %User{}} = User.set_activation(user, false)

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, {:user_active, false}} = ReceiverWorker.perform(oban_job)
	end
	end

	test "it can validate the signature" do
	Tesla.Mock.mock(fn
	%{url: "https://phpc.social/users/denniskoch"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/denniskoch.json"),
	headers: [{"content-type", "application/activity+json"}]
	}

	%{url: "https://phpc.social/users/denniskoch/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body:
	File.read!("test/fixtures/users_mock/masto_featured.json")
	\|> String.replace("{{domain}}", "phpc.social")
	\|> String.replace("{{nickname}}", "denniskoch")
	}
	end)

	params =
	File.read!("test/fixtures/receiver_worker_signature_activity.json") \|> Jason.decode!()

	req_headers = [
	["accept-encoding", "gzip"],
	["content-length", "5184"],
	["content-type", "application/activity+json"],
	["date", "Thu, 25 Jul 2024 13:33:31 GMT"],
	["digest", "SHA-256=ouge/6HP2/QryG6F3JNtZ6vzs/hSwMk67xdxe87eH7A="],
	["host", "bikeshed.party"],
	[
	"signature",
	"keyId=\"https://mastodon.social/users/bastianallgeier#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) host date digest content-type\",signature=\"ymE3vn5Iw50N6ukSp8oIuXJB5SBjGAGjBasdTDvn+ahZIzq2SIJfmVCsIIzyqIROnhWyQoTbavTclVojEqdaeOx+Ejz2wBnRBmhz5oemJLk4RnnCH0lwMWyzeY98YAvxi9Rq57Gojuv/1lBqyGa+rDzynyJpAMyFk17XIZpjMKuTNMCbjMDy76ILHqArykAIL/v1zxkgwxY/+ELzxqMpNqtZ+kQ29znNMUBB3eVZ/mNAHAz6o33Y9VKxM2jw+08vtuIZOusXyiHbRiaj2g5HtN2WBUw1MzzfRfHF2/yy7rcipobeoyk5RvP5SyHV3WrIeZ3iyoNfmv33y8fxllF0EA==\""
	],
	[
	"user-agent",
	"http.rb/5.2.0 (Mastodon/4.3.0-nightly.2024-07-25; +https://mastodon.social/)"
	]
	]

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: req_headers,
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:ok, %Pleroma.Activity{}} = ReceiverWorker.perform(oban_job)
	end

	test "cancels due to origin containment" do
	params =
	insert(:note_activity).data
	\|> Map.put("id", "https://notorigindomain.com/activity")

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, :origin_containment_failed} = ReceiverWorker.perform(oban_job)
	end

	test "canceled due to deleted object" do
	params =
	insert(:announce_activity).data
	\|> Map.put("object", "http://localhost:4001/deleted")

	Tesla.Mock.mock(fn
	%{url: "http://localhost:4001/deleted"} ->
	%Tesla.Env{
	status: 404,
	body: ""
	}
	end)

	{:ok, oban_job} =
	Federator.incoming_ap_doc(%{
	method: "POST",
	req_headers: [],
	request_path: "/inbox",
	params: params,
	query_string: ""
	})

	assert {:cancel, _} = ReceiverWorker.perform(oban_job)
	end

	describe "Server reachability:" do
	setup do
	user = insert(:user)
	remote_user = insert(:user, local: false, ap_id: "https://example.com/users/remote")
	{:ok, _, _} = Pleroma.User.follow(user, remote_user)
	{:ok, activity} = CommonAPI.post(remote_user, %{status: "Test post"})

	%{
	user: user,
	remote_user: remote_user,
	activity: activity
	}
	end

	test "schedules ReachabilityWorker if host is unreachable", %{activity: activity} do
	with_mocks [
	{Pleroma.Web.ActivityPub.Transmogrifier, [],
	[handle_incoming: fn _ -> {:ok, activity} end]},
	{Pleroma.Instances, [], [reachable?: fn _ -> false end]},
	{Pleroma.Web.Federator, [], [perform: fn :incoming_ap_doc, _params -> {:ok, nil} end]}
	] do
	job = %Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => activity.data
	}
	}

	Pleroma.Workers.ReceiverWorker.perform(job)

	assert_enqueued(
	worker: Pleroma.Workers.ReachabilityWorker,
	args: %{"domain" => "example.com"}
	)
	end
	end

	test "does not schedule ReachabilityWorker if host is reachable", %{activity: activity} do
	with_mocks [
	{Pleroma.Web.ActivityPub.Transmogrifier, [],
	[handle_incoming: fn _ -> {:ok, activity} end]},
	{Pleroma.Instances, [], [reachable?: fn _ -> true end]},
	{Pleroma.Web.Federator, [], [perform: fn :incoming_ap_doc, _params -> {:ok, nil} end]}
	] do
	job = %Oban.Job{
	args: %{
	"op" => "incoming_ap_doc",
	"params" => activity.data
	}
	}

	Pleroma.Workers.ReceiverWorker.perform(job)

	refute_enqueued(worker: Pleroma.Workers.ReachabilityWorker)
	end
	end
	end
	end
	diff --git a/test/pleroma/workers/remote_fetcher_worker_test.exs b/test/pleroma/workers/remote_fetcher_worker_test.exs
	index 6eb6932cb..a3b900a9b 100644
	--- a/test/pleroma/workers/remote_fetcher_worker_test.exs
	+++ b/test/pleroma/workers/remote_fetcher_worker_test.exs
	@@ -1,84 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.RemoteFetcherWorkerTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Workers.RemoteFetcherWorker

	@deleted_object_one "https://deleted-404.example.com/"
	@deleted_object_two "https://deleted-410.example.com/"
	@unauthorized_object "https://unauthorized.example.com/"
	@depth_object "https://depth.example.com/"
	@content_type_object "https://bad_content_type.example.com/"

	describe "RemoteFetcherWorker" do
	setup do
	Tesla.Mock.mock(fn
	%{method: :get, url: @deleted_object_one} ->
	%Tesla.Env{
	status: 404
	}

	%{method: :get, url: @deleted_object_two} ->
	%Tesla.Env{
	status: 410
	}

	%{method: :get, url: @unauthorized_object} ->
	%Tesla.Env{
	status: 403
	}

	%{method: :get, url: @depth_object} ->
	%Tesla.Env{
	status: 200
	}

	%{method: :get, url: @content_type_object} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/spoofed-object.json")
	}
	end)
	end

	test "does not retry jobs for a deleted object" do
	[
	%{"op" => "fetch_remote", "id" => @deleted_object_one},
	%{"op" => "fetch_remote", "id" => @deleted_object_two}
	]
	\|> Enum.each(fn job -> assert {:cancel, _} = perform_job(RemoteFetcherWorker, job) end)
	end

	test "does not retry jobs for an unauthorized object" do
	assert {:cancel, _} =
	perform_job(RemoteFetcherWorker, %{
	"op" => "fetch_remote",
	"id" => @unauthorized_object
	})
	end

	test "does not retry jobs for an an object that exceeded depth" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	assert {:cancel, _} =
	perform_job(RemoteFetcherWorker, %{
	"op" => "fetch_remote",
	"id" => @depth_object,
	"depth" => 1
	})
	end

	test "does not retry jobs for when object returns wrong content type" do
	assert {:cancel, _} =
	perform_job(RemoteFetcherWorker, %{
	"op" => "fetch_remote",
	"id" => @content_type_object
	})
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 6:25 AM (20 h, 20 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799675
Default Alt Text: (115 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions