No OneTemporary
Actions

Authored By

Unknown

Size

211 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	index b577e25dd..c9b421489 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,1672 +1,1672 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Delivery
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Workers.ReceiverWorker

	import Pleroma.Factory

	require Pleroma.Constants

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

	setup do: clear_config([:instance, :federating], true)

	describe "/relay" do
	setup do: clear_config([:instance, :allow_relay])

	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	Config.put([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end
	end

	describe "/internal/fetch" do
	test "it returns the internal fetch user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(200)

	assert res["id"] =~ "/fetch"
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(404)
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user with accept application/json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/activity+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/ld+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns 404 for remote users", %{
	conn: conn
	} do
	user = insert(:user, local: false, nickname: "remoteuser@example.com")

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}.json")

	assert json_response(conn, 404)
	end

	test "it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end
	end

	describe "mastodon compatibility routes" do
	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "it returns a json representation of the activity with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	{:ok, activity, _} =
	%{
	"id" => object.data["id"] <> "/activity",
	"type" => "Create",
	"object" => object.data["id"],
	"actor" => object.data["actor"],
	"to" => object.data["to"]
	}
	\|> ActivityPub.persist(local: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999/activity")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end
	end

	describe "/objects/:uuid" do
	test "it doesn't return a local-only object", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.is_local_public?(post)

	object = Object.normalize(post, false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/activity+json",
	%{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/ld+json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after object deletion", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Object.delete(note)

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/activities/:uuid" do
	test "it doesn't return a local-only activity", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.is_local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after activity deletion", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe"})

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Activity.delete_all_by_object_ap_id(activity.object.data["id"])

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	- data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()
	+ data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	@tag capture_log: true
	test "it inserts an incoming activity into the database" <>
	"even if we can't fetch the user but have it in our db",
	%{conn: conn} do
	user =
	insert(:user,
	ap_id: "https://mastodon.example.org/users/raymoo",
	ap_enabled: true,
	local: false,
	last_refreshed_at: nil
	)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> put_in(["object", "attridbutedTo"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	- data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()
	+ data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	sender_url = data["actor"]
	Instances.set_consistently_unreachable(sender_url)
	refute Instances.reachable?(sender_url)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_url)
	end

	test "accept follow activity", %{conn: conn} do
	Pleroma.Config.put([:instance, :federating], true)
	relay = Relay.get_actor()

	assert {:ok, %Activity{} = activity} = Relay.follow("https://relay.mastodon.host/actor")

	followed_relay = Pleroma.User.get_by_ap_id("https://relay.mastodon.host/actor")
	relay = refresh_record(relay)

	accept =
	File.read!("test/fixtures/relay/accept-follow.json")
	\|> String.replace("{{ap_id}}", relay.ap_id)
	\|> String.replace("{{activity_id}}", activity.data["id"])

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", accept)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.FollowingRelationship.following?(
	relay,
	followed_relay
	)

	Mix.shell(Mix.Shell.Process)

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

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])
	assert_receive {:mix_shell, :info, ["https://relay.mastodon.host/actor"]}
	end

	@tag capture_log: true
	test "without valid signature, " <>
	"it only accepts Create activities and requires enabled federation",
	%{conn: conn} do
	- data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()
	- non_create_data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()
	+ data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()
	+ non_create_data = File.read!("test/fixtures/mastodon-announce.json") \|> Jason.decode!()

	conn = put_req_header(conn, "content-type", "application/activity+json")

	Config.put([:instance, :federating], false)

	conn
	\|> post("/inbox", data)
	\|> json_response(403)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(403)

	Config.put([:instance, :federating], true)

	ret_conn = post(conn, "/inbox", data)
	assert "ok" == json_response(ret_conn, 200)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(400)
	end
	end

	describe "/users/:nickname/inbox" do
	setup do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()

	[data: data]
	end

	test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with to as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	Map.put(data, "to", user.ap_id)
	\|> Map.delete("cc")

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with cc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	Map.put(data, "cc", user.ap_id)
	\|> Map.delete("to")

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert user.ap_id in activity.recipients
	end

	test "it accepts messages with bcc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	Map.put(data, "bcc", user.ap_id)
	\|> Map.delete("to")
	\|> Map.delete("cc")

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts announces with to as string instead of array", %{conn: conn} do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "hey"})
	announcer = insert(:user, local: false)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => announcer.ap_id,
	"id" => "#{announcer.ap_id}/statuses/19512778738411822/activity",
	"object" => post.data["object"],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => [user.ap_id],
	"type" => "Announce"
	}

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.recipients
	end

	test "it accepts messages from actors that are followed by the user", %{
	conn: conn,
	data: data
	} do
	recipient = insert(:user)
	actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})

	{:ok, recipient} = User.follow(recipient, actor)

	object =
	data["object"]
	\|> Map.put("attributedTo", actor.ap_id)

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

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	sender_host = URI.parse(data["actor"]).host
	Instances.set_consistently_unreachable(sender_host)
	refute Instances.reachable?(sender_host)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_host)
	end

	test "it removes all follower collections but actor's", %{conn: conn} do
	[actor, recipient] = insert_pair(:user)

	data =
	File.read!("test/fixtures/activitypub-client-post-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()

	object = Map.put(data["object"], "attributedTo", actor.ap_id)

	data =
	data
	\|> Map.put("id", Utils.generate_object_id())
	\|> Map.put("actor", actor.ap_id)
	\|> Map.put("object", object)
	\|> Map.put("cc", [
	recipient.follower_address,
	actor.follower_address
	])
	\|> Map.put("to", [
	recipient.ap_id,
	recipient.follower_address,
	"https://www.w3.org/ns/activitystreams#Public"
	])

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	activity = Activity.get_by_ap_id(data["id"])

	assert activity.id
	assert actor.follower_address in activity.recipients
	assert actor.follower_address in activity.data["cc"]

	refute recipient.follower_address in activity.recipients
	refute recipient.follower_address in activity.data["cc"]
	refute recipient.follower_address in activity.data["to"]
	end

	test "it requires authentication", %{conn: conn} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "application/activity+json")

	ret_conn = get(conn, "/users/#{user.nickname}/inbox")
	assert json_response(ret_conn, 403)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(ret_conn, 200)
	end

	@tag capture_log: true
	test "forwarded report", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	reported_user = insert(:user)

	note = insert(:note_activity, user: reported_user)

	data = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://#{remote_domain}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	],
	"actor" => actor.ap_id,
	"cc" => [
	reported_user.ap_id
	],
	"content" => "test",
	"context" => "context",
	"id" => "http://#{remote_domain}/activities/02be56cf-35e3-46b4-b2c6-47ae08dfee9e",
	"nickname" => reported_user.nickname,
	"object" => [
	reported_user.ap_id,
	%{
	"actor" => %{
	"actor_type" => "Person",
	"approval_pending" => false,
	"avatar" => "",
	"confirmation_pending" => false,
	"deactivated" => false,
	"display_name" => "test user",
	"id" => reported_user.id,
	"local" => false,
	"nickname" => reported_user.nickname,
	"registration_reason" => nil,
	"roles" => %{
	"admin" => false,
	"moderator" => false
	},
	"tags" => [],
	"url" => reported_user.ap_id
	},
	"content" => "",
	"id" => note.data["id"],
	"published" => note.data["published"],
	"type" => "Note"
	}
	],
	"published" => note.data["published"],
	"state" => "open",
	"to" => [],
	"type" => "Flag"
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.Repo.aggregate(Activity, :count, :id) == 2

	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/Reported Account:/i
	)
	end

	@tag capture_log: true
	test "forwarded report from mastodon", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	remote_actor = "https://#{remote_domain}/actor"
	[reported_user, another] = insert_list(2, :user)

	note = insert(:note_activity, user: reported_user)

	Pleroma.Web.CommonAPI.favorite(another, note.id)

	mock_json_body =
	"test/fixtures/mastodon/application_actor.json"
	\|> File.read!()
	\|> String.replace("{{DOMAIN}}", remote_domain)

	Tesla.Mock.mock(fn %{url: ^remote_actor} ->
	%Tesla.Env{
	status: 200,
	body: mock_json_body,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => remote_actor,
	"content" => "test report",
	"id" => "https://#{remote_domain}/e3b12fd1-948c-446e-b93b-a5e67edbe1d8",
	"nickname" => reported_user.nickname,
	"object" => [
	reported_user.ap_id,
	note.data["object"]
	],
	"type" => "Flag"
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	flag_activity = "Flag" \|> Pleroma.Activity.Queries.by_type() \|> Pleroma.Repo.one()
	reported_user_ap_id = reported_user.ap_id

	[^reported_user_ap_id, flag_data] = flag_activity.data["object"]

	Enum.each(~w(actor content id published type), &Map.has_key?(flag_data, &1))
	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/#{note.data["object"]}/i
	)
	end
	end

	describe "GET /users/:nickname/outbox" do
	test "it paginates correctly", %{conn: conn} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	outbox_endpoint = user.ap_id <> "/outbox"

	_posts =
	for i <- 0..25 do
	{:ok, activity} = CommonAPI.post(user, %{status: "post #{i}"})
	activity
	end

	result =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint <> "?page=true")
	\|> json_response(200)

	result_ids = Enum.map(result["orderedItems"], fn x -> x["id"] end)
	assert length(result["orderedItems"]) == 20
	assert length(result_ids) == 20
	assert result["next"]
	assert String.starts_with?(result["next"], outbox_endpoint)

	result_next =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result["next"])
	\|> json_response(200)

	result_next_ids = Enum.map(result_next["orderedItems"], fn x -> x["id"] end)
	assert length(result_next["orderedItems"]) == 6
	assert length(result_next_ids) == 6
	refute Enum.find(result_next_ids, fn x -> x in result_ids end)
	refute Enum.find(result_ids, fn x -> x in result_next_ids end)
	assert String.starts_with?(result["id"], outbox_endpoint)

	result_next_again =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result_next["id"])
	\|> json_response(200)

	assert result_next == result_next_again
	end

	test "it returns 200 even if there're no activities", %{conn: conn} do
	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	result = json_response(conn, 200)
	assert outbox_endpoint == result["id"]
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ announce_activity.data["object"]
	end
	end

	describe "POST /users/:nickname/outbox (C2S)" do
	setup do: clear_config([:instance, :limit])

	setup do
	[
	activity: %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{"type" => "Note", "content" => "AP C2S test"},
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	]
	end

	test "it rejects posts from other users / unauthenticated users", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	other_user = insert(:user)
	conn = put_req_header(conn, "content-type", "application/activity+json")

	conn
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)

	conn
	\|> assign(:user, other_user)
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)
	end

	test "it inserts an incoming create activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])
	assert result["object"]
	assert %Object{data: object} = Object.normalize(result["object"])
	assert object["content"] == activity["object"]["content"]
	end

	test "it rejects anything beyond 'Note' creations", %{conn: conn, activity: activity} do
	user = insert(:user)

	activity =
	activity
	\|> put_in(["object", "type"], "Benis")

	_result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)
	end

	test "it inserts an incoming sensitive activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	object = Map.put(activity["object"], "sensitive", true)
	activity = Map.put(activity, "object", object)

	response =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(response["id"])
	assert response["object"]
	assert %Object{data: response_object} = Object.normalize(response["object"])
	assert response_object["sensitive"] == true
	assert response_object["content"] == activity["object"]["content"]

	representation =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(response["id"])
	\|> json_response(200)

	assert representation["object"]["sensitive"] == true
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn, activity: activity} do
	user = insert(:user)
	activity = Map.put(activity, "type", "BadType")

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end

	test "it doesn't spreads faulty attributedTo or actor fields", %{
	conn: conn,
	activity: activity
	} do
	reimu = insert(:user, nickname: "reimu")
	cirno = insert(:user, nickname: "cirno")

	assert reimu.ap_id
	assert cirno.ap_id

	activity =
	activity
	\|> put_in(["object", "actor"], reimu.ap_id)
	\|> put_in(["object", "attributedTo"], reimu.ap_id)
	\|> put_in(["actor"], reimu.ap_id)
	\|> put_in(["attributedTo"], reimu.ap_id)

	_reimu_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reimu.nickname}/outbox", activity)
	\|> json_response(403)

	cirno_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{cirno.nickname}/outbox", activity)
	\|> json_response(201)

	assert cirno_outbox["attributedTo"] == nil
	assert cirno_outbox["actor"] == cirno.ap_id

	assert cirno_object = Object.normalize(cirno_outbox["object"])
	assert cirno_object.data["actor"] == cirno.ap_id
	assert cirno_object.data["attributedTo"] == cirno.ap_id
	end

	test "Character limitation", %{conn: conn, activity: activity} do
	Pleroma.Config.put([:instance, :limit], 5)
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)

	assert result == "Note is over the character limit"
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/followers")
	\|> json_response(404)
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/following")
	\|> json_response(404)
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user_two)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_followers: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{other_user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_followers: true)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additional ActivityPub C2S endpoints" do
	test "GET /api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

	assert UserView.render("user.json", %{user: user}) == json_response(conn, 200)

	conn
	\|> get("/api/ap/whoami")
	\|> json_response(403)
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	test "POST /api/ap/upload_media", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "bad/content-type",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.png"
	}

	object =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(:created)

	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	assert [%{"href" => object_href, "mediaType" => object_mediatype}] = object["url"]
	assert is_binary(object_href)
	assert object_mediatype == "image/jpeg"
	assert String.ends_with?(object_href, ".jpg")

	activity_request = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test, attachment",
	"attachment" => [object]
	},
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}

	activity_response =
	conn
	\|> assign(:user, user)
	\|> post("/users/#{user.nickname}/outbox", activity_request)
	\|> json_response(:created)

	assert activity_response["id"]
	assert activity_response["object"]
	assert activity_response["actor"] == user.ap_id

	assert %Object{data: %{"attachment" => [attachment]}} =
	Object.normalize(activity_response["object"])

	assert attachment["type"] == "Document"
	assert attachment["name"] == desc

	assert [
	%{
	"href" => ^object_href,
	"type" => "Link",
	"mediaType" => ^object_mediatype
	}
	] = attachment["url"]

	# Fails if unauthenticated
	conn
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(403)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/object_age_policy_test.exs b/test/pleroma/web/activity_pub/mrf/object_age_policy_test.exs
	index cf6acc9a2..e8317b2af 100644
	--- a/test/pleroma/web/activity_pub/mrf/object_age_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/object_age_policy_test.exs
	@@ -1,148 +1,148 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest do
	use Pleroma.DataCase
	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy
	alias Pleroma.Web.ActivityPub.Visibility

	setup do:
	clear_config(:mrf_object_age,
	threshold: 172_800,
	actions: [:delist, :strip_followers]
	)

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

	defp get_old_message do
	File.read!("test/fixtures/mastodon-post-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	end

	defp get_new_message do
	old_message = get_old_message()

	new_object =
	old_message
	\|> Map.get("object")
	\|> Map.put("published", DateTime.utc_now() \|> DateTime.to_iso8601())

	old_message
	\|> Map.put("object", new_object)
	end

	describe "with reject action" do
	test "works with objects with empty to or cc fields" do
	Config.put([:mrf_object_age, :actions], [:reject])

	data =
	get_old_message()
	\|> Map.put("cc", nil)
	\|> Map.put("to", nil)

	assert match?({:reject, _}, ObjectAgePolicy.filter(data))
	end

	test "it rejects an old post" do
	Config.put([:mrf_object_age, :actions], [:reject])

	data = get_old_message()

	assert match?({:reject, _}, ObjectAgePolicy.filter(data))
	end

	test "it allows a new post" do
	Config.put([:mrf_object_age, :actions], [:reject])

	data = get_new_message()

	assert match?({:ok, _}, ObjectAgePolicy.filter(data))
	end
	end

	describe "with delist action" do
	test "works with objects with empty to or cc fields" do
	Config.put([:mrf_object_age, :actions], [:delist])

	data =
	get_old_message()
	\|> Map.put("cc", nil)
	\|> Map.put("to", nil)

	{:ok, _u} = User.get_or_fetch_by_ap_id(data["actor"])

	{:ok, data} = ObjectAgePolicy.filter(data)

	assert Visibility.get_visibility(%{data: data}) == "unlisted"
	end

	test "it delists an old post" do
	Config.put([:mrf_object_age, :actions], [:delist])

	data = get_old_message()

	{:ok, _u} = User.get_or_fetch_by_ap_id(data["actor"])

	{:ok, data} = ObjectAgePolicy.filter(data)

	assert Visibility.get_visibility(%{data: data}) == "unlisted"
	end

	test "it allows a new post" do
	Config.put([:mrf_object_age, :actions], [:delist])

	data = get_new_message()

	{:ok, _user} = User.get_or_fetch_by_ap_id(data["actor"])

	assert match?({:ok, ^data}, ObjectAgePolicy.filter(data))
	end
	end

	describe "with strip_followers action" do
	test "works with objects with empty to or cc fields" do
	Config.put([:mrf_object_age, :actions], [:strip_followers])

	data =
	get_old_message()
	\|> Map.put("cc", nil)
	\|> Map.put("to", nil)

	{:ok, user} = User.get_or_fetch_by_ap_id(data["actor"])

	{:ok, data} = ObjectAgePolicy.filter(data)

	refute user.follower_address in data["to"]
	refute user.follower_address in data["cc"]
	end

	test "it strips followers collections from an old post" do
	Config.put([:mrf_object_age, :actions], [:strip_followers])

	data = get_old_message()

	{:ok, user} = User.get_or_fetch_by_ap_id(data["actor"])

	{:ok, data} = ObjectAgePolicy.filter(data)

	refute user.follower_address in data["to"]
	refute user.follower_address in data["cc"]
	end

	test "it allows a new post" do
	Config.put([:mrf_object_age, :actions], [:strip_followers])

	data = get_new_message()

	{:ok, _u} = User.get_or_fetch_by_ap_id(data["actor"])

	assert match?({:ok, ^data}, ObjectAgePolicy.filter(data))
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs
	index c6ff96f08..0d431df18 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs
	@@ -1,91 +1,91 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

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

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

	assert activity.data["id"] == accept_data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

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

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true

	follower = User.get_by_id(follower.id)
	assert follower.following_count == 1

	followed = User.get_by_id(followed.id)
	assert followed.follower_count == 1
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

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

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/announce_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/announce_handling_test.exs
	index 99c296c74..c06bbc5e9 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/announce_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/announce_handling_test.exs
	@@ -1,176 +1,176 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	test "it works for incoming honk announces" do
	user = insert(:user, ap_id: "https://honktest/u/test", local: false)
	other_user = insert(:user)
	{:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})

	announce = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://honktest/u/test",
	"id" => "https://honktest/u/test/bonk/1793M7B9MQ48847vdx",
	"object" => post.data["object"],
	"published" => "2019-06-25T19:33:58Z",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"type" => "Announce"
	}

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

	object = Object.get_by_ap_id(post.data["object"])

	assert length(object.data["announcements"]) == 1
	assert user.ap_id in object.data["announcements"]
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	- data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()
	+ data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Jason.decode!()

	_user = insert(:user, local: false, ap_id: data["actor"]["id"])
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(other_user, %{status: "kroegeroeg"})

	data =
	data
	\|> put_in(["object", "id"], post.data["object"])

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

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming announces, fetching the announced object" do
	data =
	File.read!("test/fixtures/mastodon-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", "http://mastodon.example.org/users/admin/statuses/99541947525187367")

	Tesla.Mock.mock(fn
	%{method: :get} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-note-object.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}
	end)

	_user = insert(:user, local: false, ap_id: data["actor"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert(Activity.get_create_by_object_ap_id(data["object"]))
	end

	@tag capture_log: true
	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	_user = insert(:user, local: false, ap_id: data["actor"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

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

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

	# Ignore inlined activities for now
	@tag skip: true
	test "it works for incoming announces with an inlined activity" do
	data =
	File.read!("test/fixtures/mastodon-announce-private.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()

	_user =
	insert(:user,
	local: false,
	ap_id: data["actor"],
	follower_address: data["actor"] <> "/followers"
	)

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	object = Object.normalize(data["object"])

	assert object.data["id"] == "http://mastodon.example.org/@admin/99541947525187368"
	assert object.data["content"] == "this is a private toot"
	end

	@tag capture_log: true
	test "it rejects incoming announces with an inlined activity from another origin" do
	Tesla.Mock.mock(fn
	%{method: :get} -> %Tesla.Env{status: 404, body: ""}
	end)

	data =
	File.read!("test/fixtures/bogus-mastodon-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()

	_user = insert(:user, local: false, ap_id: data["actor"])

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

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", Object.normalize(activity).data["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

	_user =
	insert(:user,
	local: false,
	ap_id: data["actor"],
	follower_address: "http://mastodon.example.org/users/admin/followers"
	)

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

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
	index e7d85a2c5..a1c2ba28a 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
	@@ -1,79 +1,79 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

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

	test "incoming, rewrites Note to Answer and increments vote counters" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	object = Object.normalize(activity)
	assert object.data["repliesCount"] == nil

	data =
	File.read!("test/fixtures/mastodon-vote.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	answer_object = Object.normalize(activity)
	assert answer_object.data["type"] == "Answer"
	assert answer_object.data["inReplyTo"] == object.data["id"]

	new_object = Object.get_by_ap_id(object.data["id"])
	assert new_object.data["repliesCount"] == nil

	assert Enum.any?(
	new_object.data["oneOf"],
	fn
	%{"name" => "suya..", "replies" => %{"totalItems" => 1}} -> true
	_ -> false
	end
	)
	end

	test "outgoing, rewrites Answer to Note" do
	user = insert(:user)

	{:ok, poll_activity} =
	CommonAPI.post(user, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	poll_object = Object.normalize(poll_activity)
	# TODO: Replace with CommonAPI vote creation when implemented
	data =
	File.read!("test/fixtures/mastodon-vote.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], poll_object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

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

	assert data["object"]["type"] == "Note"
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/audio_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/audio_handling_test.exs
	index 6eeb1c863..7a2ac5d4d 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/audio_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/audio_handling_test.exs
	@@ -1,85 +1,85 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	test "it works for incoming listens" do
	_user = insert(:user, ap_id: "http://mastodon.example.org/users/admin")

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Listen",
	"id" => "http://mastodon.example.org/users/admin/listens/1234/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"object" => %{
	"type" => "Audio",
	"id" => "http://mastodon.example.org/users/admin/listens/1234",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"title" => "lain radio episode 1",
	"artist" => "lain",
	"album" => "lain radio",
	"length" => 180_000
	}
	}

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

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"
	assert object.data["artist"] == "lain"
	assert object.data["album"] == "lain radio"
	assert object.data["length"] == 180_000
	end

	test "Funkwhale Audio object" do
	Tesla.Mock.mock(fn
	%{url: "https://channels.tests.funkwhale.audio/federation/actors/compositions"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/funkwhale_channel.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}
	end)

	- data = File.read!("test/fixtures/tesla_mock/funkwhale_create_audio.json") \|> Poison.decode!()
	+ data = File.read!("test/fixtures/tesla_mock/funkwhale_create_audio.json") \|> Jason.decode!()

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

	assert object = Object.normalize(activity, false)

	assert object.data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

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

	assert object.data["url"] == "https://channels.tests.funkwhale.audio/library/tracks/74"

	assert object.data["attachment"] == [
	%{
	"mediaType" => "audio/ogg",
	"type" => "Link",
	"name" => nil,
	"blurhash" => nil,
	"url" => [
	%{
	"href" =>
	"https://channels.tests.funkwhale.audio/api/v1/listen/3901e5d8-0445-49d5-9711-e096cf32e515/?upload=42342395-0208-4fee-a38d-259a6dae0871&download=false",
	"mediaType" => "audio/ogg",
	"type" => "Link"
	}
	]
	}
	]
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs
	index 71f1a0ed5..b8e4ad827 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs
	@@ -1,63 +1,63 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

	test "it works for incoming blocks" do
	user = insert(:user)

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

	blocker = insert(:user, ap_id: data["actor"])

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

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

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

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

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_cached_by_ap_id(data["actor"])
	blocked = User.get_cached_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs b/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs
	index 31274c067..2adaa1ade 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs
	@@ -1,171 +1,171 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import Pleroma.Factory

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs
	index c9a53918c..cffaa7c44 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs
	@@ -1,114 +1,114 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

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

	test "it works for incoming deletes" do
	activity = insert(:note_activity)
	deleting_user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", deleting_user.ap_id)
	\|> put_in(["object", "id"], activity.data["object"])

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

	assert id == data["id"]

	# We delete the Create activity because we base our timelines on it.
	# This should be changed after we unify objects and activities
	refute Activity.get_by_id(activity.id)
	assert actor == deleting_user.ap_id

	# Objects are replaced by a tombstone object.
	object = Object.normalize(activity.data["object"])
	assert object.data["type"] == "Tombstone"
	end

	test "it works for incoming when the object has been pruned" do
	activity = insert(:note_activity)

	{:ok, object} =
	Object.normalize(activity.data["object"])
	\|> Repo.delete()

	Cachex.del(:object_cache, "object:#{object.data["id"]}")

	deleting_user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", deleting_user.ap_id)
	\|> put_in(["object", "id"], activity.data["object"])

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

	assert id == data["id"]

	# We delete the Create activity because we base our timelines on it.
	# This should be changed after we unify objects and activities
	refute Activity.get_by_id(activity.id)
	assert actor == deleting_user.ap_id
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)
	%{ap_id: ap_id} = insert(:user, ap_id: "https://gensokyo.2hu/users/raymoo")

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", ap_id)
	\|> put_in(["object", "id"], activity.data["object"])

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

	@tag capture_log: true
	test "it works for incoming user deletes" do
	%{ap_id: ap_id} = insert(:user, ap_id: "http://mastodon.example.org/users/admin")

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()

	{:ok, _} = Transmogrifier.handle_incoming(data)
	ObanHelpers.perform_all()

	assert User.get_cached_by_ap_id(ap_id).deactivated
	end

	test "it fails for incoming user deletes with spoofed origin" do
	%{ap_id: ap_id} = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", ap_id)

	assert match?({:error, _}, Transmogrifier.handle_incoming(data))

	assert User.get_cached_by_ap_id(ap_id)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
	index 0fb056b50..aea4ed6f8 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
	@@ -1,61 +1,61 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	test "it works for incoming emoji reactions" do
	user = insert(:user)
	other_user = insert(:user, local: false)
	{:ok, activity} = CommonAPI.post(user, %{status: "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", other_user.ap_id)

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

	assert data["actor"] == other_user.ap_id
	assert data["type"] == "EmojiReact"
	assert data["id"] == "http://mastodon.example.org/users/admin#reactions/2"
	assert data["object"] == activity.data["object"]
	assert data["content"] == "👌"

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

	assert object.data["reaction_count"] == 1
	assert match?([["👌", _]], object.data["reactions"])
	end

	test "it reject invalid emoji reactions" do
	user = insert(:user)
	other_user = insert(:user, local: false)
	{:ok, activity} = CommonAPI.post(user, %{status: "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction-too-long.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", other_user.ap_id)

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

	data =
	File.read!("test/fixtures/emoji-reaction-no-emoji.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", other_user.ap_id)

	assert {:error, _} = Transmogrifier.handle_incoming(data)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
	index 4ef8210ad..985c26def 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
	@@ -1,208 +1,208 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.FollowHandlingTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Factory
	import Ecto.Query
	import Mock

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

	describe "handle_incoming" do
	setup do: clear_config([:user, :deny_follow_blocked])

	test "it works for osada follow request" do
	user = insert(:user)

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

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

	assert data["actor"] == "https://apfed.club/channel/indio"
	assert data["type"] == "Follow"
	assert data["id"] == "https://apfed.club/follow/9"

	activity = Repo.get(Activity, activity.id)
	assert activity.data["state"] == "accept"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follow requests" do
	user = insert(:user)

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

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Follow"
	assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"

	activity = Repo.get(Activity, activity.id)
	assert activity.data["state"] == "accept"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)

	[notification] = Notification.for_user(user)
	assert notification.type == "follow"
	end

	test "with locked accounts, it does create a Follow, but not an Accept" do
	user = insert(:user, is_locked: true)

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

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

	assert data["state"] == "pending"

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

	accepts =
	from(
	a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Accept")
	)
	\|> Repo.all()

	assert Enum.empty?(accepts)

	[notification] = Notification.for_user(user)
	assert notification.type == "follow_request"
	end

	test "it works for follow requests when you are already followed, creating a new accept activity" do
	# This is important because the remote might have the wrong idea about the
	# current follow status. This can lead to instance A thinking that x@A is
	# followed by y@B, but B thinks they are not. In this case, the follow can
	# never go through again because it will never get an Accept.
	user = insert(:user)

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

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

	accepts =
	from(
	a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Accept")
	)
	\|> Repo.all()

	assert length(accepts) == 1

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("id", String.replace(data["id"], "2", "3"))
	\|> Map.put("object", user.ap_id)

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

	accepts =
	from(
	a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Accept")
	)
	\|> Repo.all()

	assert length(accepts) == 2
	end

	test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)

	user = insert(:user)
	{:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")

	{:ok, _user_relationship} = User.block(user, target)

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

	{:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)

	%Activity{} = activity = Activity.get_by_ap_id(id)

	assert activity.data["state"] == "reject"
	end

	test "it rejects incoming follow requests if the following errors for some reason" do
	user = insert(:user)

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

	with_mock Pleroma.User, [:passthrough], follow: fn _, _, _ -> {:error, :testing} end do
	{:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)

	%Activity{} = activity = Activity.get_by_ap_id(id)

	assert activity.data["state"] == "reject"
	end
	end

	test "it works for incoming follow requests from hubzilla" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/hubzilla-follow-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Utils.normalize_params()

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

	assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
	assert data["type"] == "Follow"
	assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follows to locked account" do
	pending_follower = insert(:user, ap_id: "http://mastodon.example.org/users/admin")
	user = insert(:user, is_locked: true)

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

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

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

	assert [^pending_follower] = User.get_follow_requests(user)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs
	index 53fe1d550..967bad151 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs
	@@ -1,78 +1,78 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	test "it works for incoming likes" do
	user = insert(:user)

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

	data =
	File.read!("test/fixtures/mastodon-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	_actor = insert(:user, ap_id: data["actor"], local: false)

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

	refute Enum.empty?(activity.recipients)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	assert data["object"] == activity.data["object"]
	end

	test "it works for incoming misskey likes, turning them into EmojiReacts" do
	user = insert(:user)

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

	data =
	File.read!("test/fixtures/misskey-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	_actor = insert(:user, ap_id: data["actor"], local: false)

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

	assert activity_data["actor"] == data["actor"]
	assert activity_data["type"] == "EmojiReact"
	assert activity_data["id"] == data["id"]
	assert activity_data["object"] == activity.data["object"]
	assert activity_data["content"] == "🍮"
	end

	test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReacts" do
	user = insert(:user)

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

	data =
	File.read!("test/fixtures/misskey-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("_misskey_reaction", "⭐")

	_actor = insert(:user, ap_id: data["actor"], local: false)

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

	assert activity_data["actor"] == data["actor"]
	assert activity_data["type"] == "EmojiReact"
	assert activity_data["id"] == data["id"]
	assert activity_data["object"] == activity.data["object"]
	assert activity_data["content"] == "⭐"
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs
	index d2822ce75..47f92cf4d 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/question_handling_test.exs
	@@ -1,176 +1,176 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

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

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

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

	object = Object.normalize(activity, false)

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

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

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

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

	assert object.data["context_id"]

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

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

	user = insert(:user)

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

	reply_object = Object.normalize(reply_activity, false)

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

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

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

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

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

	test "Mastodon Question activity with custom emojis" do
	options = [
	%{
	"type" => "Note",
	"name" => ":blobcat:",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => ":blobfox:",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	}
	]

	tag = [
	%{
	"icon" => %{
	"type" => "Image",
	"url" => "https://blob.cat/emoji/custom/blobcats/blobcat.png"
	},
	"id" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	"name" => ":blobcat:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	},
	%{
	"icon" => %{"type" => "Image", "url" => "https://blob.cat/emoji/blobfox/blobfox.png"},
	"id" => "https://blob.cat/emoji/blobfox/blobfox.png",
	"name" => ":blobfox:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]

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

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

	assert object.data["oneOf"] == options

	assert object.data["emoji"] == %{
	"blobcat" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	"blobfox" => "https://blob.cat/emoji/blobfox/blobfox.png"
	}
	end

	test "returns same activity if received a second time" do
	- data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()
	+ data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Jason.decode!()

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

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

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

	assert {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs
	index 5c1451def..cc28eb7ef 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs
	@@ -1,67 +1,67 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

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

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

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

	:error = Transmogrifier.handle_incoming(data)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs
	index 8683f7135..fcfc7b4b6 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs
	@@ -1,185 +1,185 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Pleroma.Factory

	test "it works for incoming emoji reaction undos" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hello"})
	{:ok, reaction_activity} = CommonAPI.react_with_emoji(activity.id, user, "👌")

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", reaction_activity.data["id"])
	\|> Map.put("actor", user.ap_id)

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

	assert activity.actor == user.ap_id
	assert activity.data["id"] == data["id"]
	assert activity.data["type"] == "Undo"
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	_liker = insert(:user, ap_id: like_data["actor"], local: false)

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

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"] == "http://mastodon.example.org/users/admin#likes/2"

	note = Object.get_by_ap_id(like_data["object"])
	assert note.data["like_count"] == 0
	assert note.data["likes"] == []
	end

	test "it works for incoming unlikes with an existing like activity and a compact object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	_liker = insert(:user, ap_id: like_data["actor"], local: false)

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

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", like_data["id"])
	\|> Map.put("actor", like_data["actor"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	announce_data =
	File.read!("test/fixtures/mastodon-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])

	_announcer = insert(:user, ap_id: announce_data["actor"], local: false)

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

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

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

	assert data["type"] == "Undo"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

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

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

	_follower = insert(:user, ap_id: follow_data["actor"], local: false)

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

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

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

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

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

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

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

	_blocker = insert(:user, ap_id: block_data["actor"], local: false)

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

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

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"] == block_data["id"]

	blocker = User.get_cached_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	index 7c4d16db7..c62d5e139 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	@@ -1,159 +1,159 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

	test "it works for incoming update activities" do
	user = insert(:user, local: false)

	- update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()
	+ update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

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

	assert data["id"] == update_data["id"]

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works with alsoKnownAs" do
	%{ap_id: actor} = insert(:user, local: false)

	assert User.get_cached_by_ap_id(actor).also_known_as == []

	{:ok, _activity} =
	"test/fixtures/mastodon-update.json"
	\|> File.read!()
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("actor", actor)
	\|> Map.update!("object", fn object ->
	object
	\|> Map.put("actor", actor)
	\|> Map.put("id", actor)
	\|> Map.put("alsoKnownAs", [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	])
	end)
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	]
	end

	test "it works with custom profile fields" do
	user = insert(:user, local: false)

	assert user.fields == []

	- update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()
	+ update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	Pleroma.Config.put([:instance, :max_remote_account_fields], 2)

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [
	%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
	%{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
	%{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
	])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == []
	end

	test "it works for incoming update activities which lock the account" do
	user = insert(:user, local: false)

	- update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()
	+ update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

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

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.is_locked == true
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index 333bb4f9b..66ea7664a 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,507 +1,507 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert :error = Transmogrifier.handle_incoming(message)

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

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

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

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

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

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

	assert modified["object"]["content"] == "hey"
	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

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

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

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

	object = modified["object"]

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

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

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

	test "it adds the sensitive property" do
	user = insert(:user)

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

	assert modified["object"]["sensitive"]
	end

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

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

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

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

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

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

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert modified["directMessage"] == false

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

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

	assert modified["directMessage"] == false

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

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

	assert modified["directMessage"] == true
	end

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

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

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

	assert is_nil(modified["bcc"])
	end

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

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

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

	user = insert(:user)

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

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

	describe "user upgrade" do
	test "it upgrades a user to activitypub" do
	user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	user_two = insert(:user)
	Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept)

	{:ok, activity} = CommonAPI.post(user, %{status: "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{status: "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	ObanHelpers.perform_all()

	assert user.ap_enabled
	assert user.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"
	assert user.following_address == "https://niu.moe/users/rye/following"

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 1

	activity = Activity.get_by_id(activity.id)
	assert user.follower_address in activity.recipients

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]
	} = user.avatar

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]
	} = user.banner

	refute "..." in activity.recipients

	unrelated_activity = Activity.get_by_id(unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = User.get_cached_by_id(user_two.id)
	assert User.following?(user_two, user)
	refute "..." in User.following(user_two)
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	fixed_object = Transmogrifier.fix_explicit_addressing(object)

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

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

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

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

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

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

	@tag capture_log: true
	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)
	end
	end
	end
	diff --git a/test/pleroma/web/federator_test.exs b/test/pleroma/web/federator_test.exs
	index 592fdccd1..67001add7 100644
	--- a/test/pleroma/web/federator_test.exs
	+++ b/test/pleroma/web/federator_test.exs
	@@ -1,173 +1,173 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.FederatorTest do
	alias Pleroma.Instances
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.PublisherWorker

	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import Mock

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

	:ok
	end

	setup_all do: clear_config([:instance, :federating], true)
	setup do: clear_config([:instance, :allow_relay])
	setup do: clear_config([:mrf, :policies])
	setup do: clear_config([:mrf_keyword])

	describe "Publish an activity" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI"})

	relay_mock = {
	Pleroma.Web.ActivityPub.Relay,
	[],
	[publish: fn _activity -> send(self(), :relay_publish) end]
	}

	%{activity: activity, relay_mock: relay_mock}
	end

	test "with relays active, it publishes to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	with_mocks([relay_mock]) do
	Federator.publish(activity)
	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))
	end

	assert_received :relay_publish
	end

	test "with relays deactivated, it does not publish to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	Pleroma.Config.put([:instance, :allow_relay], false)

	with_mocks([relay_mock]) do
	Federator.publish(activity)
	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))
	end

	refute_received :relay_publish
	end
	end

	describe "Targets reachability filtering in `publish`" do
	test "it federates only to reachable instances via AP" do
	user = insert(:user)

	{inbox1, inbox2} =
	{"https://domain.com/users/nick1/inbox", "https://domain2.com/users/nick2/inbox"}

	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	inbox: inbox1,
	ap_enabled: true
	})

	insert(:user, %{
	local: false,
	nickname: "nick2@domain2.com",
	ap_id: "https://domain2.com/users/nick2",
	inbox: inbox2,
	ap_enabled: true
	})

	dt = NaiveDateTime.utc_now()
	Instances.set_unreachable(inbox1, dt)

	Instances.set_consistently_unreachable(URI.parse(inbox2).host)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "HI @nick1@domain.com, @nick2@domain2.com!"})

	expected_dt = NaiveDateTime.to_iso8601(dt)

	ObanHelpers.perform(all_enqueued(worker: PublisherWorker))

	assert ObanHelpers.member?(
	%{
	"op" => "publish_one",
	"params" => %{"inbox" => inbox1, "unreachable_since" => expected_dt}
	},
	all_enqueued(worker: PublisherWorker)
	)
	end
	end

	describe "Receive an activity" do
	test "successfully processes incoming AP docs with correct origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin"
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:ok, _activity} = ObanHelpers.perform(job)

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:error, :already_present} = ObanHelpers.perform(job)
	end

	test "rejects incoming AP docs with incorrect origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://niu.moe/users/rye",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin"
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:error, :origin_containment_failed} = ObanHelpers.perform(job)
	end

	test "it does not crash if MRF rejects the post" do
	Pleroma.Config.put([:mrf_keyword, :reject], ["lain"])

	Pleroma.Config.put(
	[:mrf, :policies],
	Pleroma.Web.ActivityPub.MRF.KeywordPolicy
	)

	params =
	File.read!("test/fixtures/mastodon-post-activity.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()

	assert {:ok, job} = Federator.incoming_ap_doc(params)
	assert {:error, _} = ObanHelpers.perform(job)
	end
	end
	end
	diff --git a/test/pleroma/web/o_auth/o_auth_controller_test.exs b/test/pleroma/web/o_auth/o_auth_controller_test.exs
	index a00df8cc7..c6526d8c9 100644
	--- a/test/pleroma/web/o_auth/o_auth_controller_test.exs
	+++ b/test/pleroma/web/o_auth/o_auth_controller_test.exs
	@@ -1,1232 +1,1232 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.OAuthControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory

	alias Pleroma.MFA
	alias Pleroma.MFA.TOTP
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.OAuthController
	alias Pleroma.Web.OAuth.Token

	@session_opts [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]
	setup do
	clear_config([:instance, :account_activation_required])
	clear_config([:instance, :account_approval_required])
	end

	describe "in OAuth consumer mode, " do
	setup do
	[
	app: insert(:oauth_app),
	conn:
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session()
	]
	end

	setup do: clear_config([:auth, :oauth_consumer_strategies], ~w(twitter facebook))

	test "GET /oauth/authorize renders auth forms, including OAuth consumer form", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"scope" => "read"
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ "Sign in with Twitter"
	assert response =~ o_auth_path(conn, :prepare_request)
	end

	test "GET /oauth/prepare_request encodes parameters as `state` and redirects", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/prepare_request",
	%{
	"provider" => "twitter",
	"authorization" => %{
	"scope" => "read follow",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => "a_state"
	}
	}
	)

	assert html_response(conn, 302)

	redirect_query = URI.parse(redirected_to(conn)).query
	assert %{"state" => state_param} = URI.decode_query(redirect_query)
	- assert {:ok, state_components} = Poison.decode(state_param)
	+ assert {:ok, state_components} = Jason.decode(state_param)

	expected_client_id = app.client_id
	expected_redirect_uri = app.redirect_uris

	assert %{
	"scope" => "read follow",
	"client_id" => ^expected_client_id,
	"redirect_uri" => ^expected_redirect_uri,
	"state" => "a_state"
	} = state_components
	end

	test "with user-bound registration, GET /oauth/<provider>/callback redirects to `redirect_uri` with `code`",
	%{app: app, conn: conn} do
	registration = insert(:registration)
	redirect_uri = OAuthController.default_redirect_uri(app)

	state_params = %{
	"scope" => Enum.join(app.scopes, " "),
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"state" => ""
	}

	conn =
	conn
	\|> assign(:ueberauth_auth, %{provider: registration.provider, uid: registration.uid})
	\|> get(
	"/oauth/twitter/callback",
	%{
	"oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	"oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	"provider" => "twitter",
	- "state" => Poison.encode!(state_params)
	+ "state" => Jason.encode!(state_params)
	}
	)

	assert html_response(conn, 302)
	assert redirected_to(conn) =~ ~r/#{redirect_uri}\?code=.+/
	end

	test "with user-unbound registration, GET /oauth/<provider>/callback renders registration_details page",
	%{app: app, conn: conn} do
	user = insert(:user)

	state_params = %{
	"scope" => "read write",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => "a_state"
	}

	conn =
	conn
	\|> assign(:ueberauth_auth, %{
	provider: "twitter",
	uid: "171799000",
	info: %{nickname: user.nickname, email: user.email, name: user.name, description: nil}
	})
	\|> get(
	"/oauth/twitter/callback",
	%{
	"oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	"oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	"provider" => "twitter",
	- "state" => Poison.encode!(state_params)
	+ "state" => Jason.encode!(state_params)
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ ~r/name="op" type="submit" value="register"/
	assert response =~ ~r/name="op" type="submit" value="connect"/
	assert response =~ user.email
	assert response =~ user.nickname
	end

	test "on authentication error, GET /oauth/<provider>/callback redirects to `redirect_uri`", %{
	app: app,
	conn: conn
	} do
	state_params = %{
	"scope" => Enum.join(app.scopes, " "),
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => ""
	}

	conn =
	conn
	\|> assign(:ueberauth_failure, %{errors: [%{message: "(error description)"}]})
	\|> get(
	"/oauth/twitter/callback",
	%{
	"oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	"oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	"provider" => "twitter",
	- "state" => Poison.encode!(state_params)
	+ "state" => Jason.encode!(state_params)
	}
	)

	assert html_response(conn, 302)
	assert redirected_to(conn) == app.redirect_uris
	assert get_flash(conn, :error) == "Failed to authenticate: (error description)."
	end

	test "GET /oauth/registration_details renders registration details form", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/registration_details",
	%{
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => "a_state",
	"nickname" => nil,
	"email" => "john@doe.com"
	}
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ ~r/name="op" type="submit" value="register"/
	assert response =~ ~r/name="op" type="submit" value="connect"/
	end

	test "with valid params, POST /oauth/register?op=register redirects to `redirect_uri` with `code`",
	%{
	app: app,
	conn: conn
	} do
	registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})
	redirect_uri = OAuthController.default_redirect_uri(app)

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post(
	"/oauth/register",
	%{
	"op" => "register",
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"state" => "a_state",
	"nickname" => "availablenick",
	"email" => "available@email.com"
	}
	}
	)

	assert html_response(conn, 302)
	assert redirected_to(conn) =~ ~r/#{redirect_uri}\?code=.+/
	end

	test "with unlisted `redirect_uri`, POST /oauth/register?op=register results in HTTP 401",
	%{
	app: app,
	conn: conn
	} do
	registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})
	unlisted_redirect_uri = "http://cross-site-request.com"

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post(
	"/oauth/register",
	%{
	"op" => "register",
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => unlisted_redirect_uri,
	"state" => "a_state",
	"nickname" => "availablenick",
	"email" => "available@email.com"
	}
	}
	)

	assert html_response(conn, 401)
	end

	test "with invalid params, POST /oauth/register?op=register renders registration_details page",
	%{
	app: app,
	conn: conn
	} do
	another_user = insert(:user)
	registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})

	params = %{
	"op" => "register",
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => "a_state",
	"nickname" => "availablenickname",
	"email" => "available@email.com"
	}
	}

	for {bad_param, bad_param_value} <-
	[{"nickname", another_user.nickname}, {"email", another_user.email}] do
	bad_registration_attrs = %{
	"authorization" => Map.put(params["authorization"], bad_param, bad_param_value)
	}

	bad_params = Map.merge(params, bad_registration_attrs)

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post("/oauth/register", bad_params)

	assert html_response(conn, 403) =~ ~r/name="op" type="submit" value="register"/
	assert get_flash(conn, :error) == "Error: #{bad_param} has already been taken."
	end
	end

	test "with valid params, POST /oauth/register?op=connect redirects to `redirect_uri` with `code`",
	%{
	app: app,
	conn: conn
	} do
	user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("testpassword"))
	registration = insert(:registration, user: nil)
	redirect_uri = OAuthController.default_redirect_uri(app)

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post(
	"/oauth/register",
	%{
	"op" => "connect",
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"state" => "a_state",
	"name" => user.nickname,
	"password" => "testpassword"
	}
	}
	)

	assert html_response(conn, 302)
	assert redirected_to(conn) =~ ~r/#{redirect_uri}\?code=.+/
	end

	test "with unlisted `redirect_uri`, POST /oauth/register?op=connect results in HTTP 401`",
	%{
	app: app,
	conn: conn
	} do
	user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("testpassword"))
	registration = insert(:registration, user: nil)
	unlisted_redirect_uri = "http://cross-site-request.com"

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post(
	"/oauth/register",
	%{
	"op" => "connect",
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => unlisted_redirect_uri,
	"state" => "a_state",
	"name" => user.nickname,
	"password" => "testpassword"
	}
	}
	)

	assert html_response(conn, 401)
	end

	test "with invalid params, POST /oauth/register?op=connect renders registration_details page",
	%{
	app: app,
	conn: conn
	} do
	user = insert(:user)
	registration = insert(:registration, user: nil)

	params = %{
	"op" => "connect",
	"authorization" => %{
	"scopes" => app.scopes,
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => "a_state",
	"name" => user.nickname,
	"password" => "wrong password"
	}
	}

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post("/oauth/register", params)

	assert html_response(conn, 401) =~ ~r/name="op" type="submit" value="connect"/
	assert get_flash(conn, :error) == "Invalid Username/Password"
	end
	end

	describe "GET /oauth/authorize" do
	setup do
	[
	app: insert(:oauth_app, redirect_uris: "https://redirect.url"),
	conn:
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session()
	]
	end

	test "renders authentication page", %{app: app, conn: conn} do
	conn =
	get(
	conn,
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"scope" => "read"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "properly handles internal calls with `authorization`-wrapped params", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/authorize",
	%{
	"authorization" => %{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"scope" => "read"
	}
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "renders authentication page if user is already authenticated but `force_login` is tru-ish",
	%{app: app, conn: conn} do
	token = insert(:oauth_token, app: app)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"scope" => "read",
	"force_login" => "true"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "renders authentication page if user is already authenticated but user request with another client",
	%{
	app: app,
	conn: conn
	} do
	token = insert(:oauth_token, app: app)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => "another_client_id",
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"scope" => "read"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "with existing authentication and non-OOB `redirect_uri`, redirects to app with `token` and `state` params",
	%{
	app: app,
	conn: conn
	} do
	token = insert(:oauth_token, app: app)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"state" => "specific_client_state",
	"scope" => "read"
	}
	)

	assert URI.decode(redirected_to(conn)) ==
	"https://redirect.url?access_token=#{token.token}&state=specific_client_state"
	end

	test "with existing authentication and unlisted non-OOB `redirect_uri`, redirects without credentials",
	%{
	app: app,
	conn: conn
	} do
	unlisted_redirect_uri = "http://cross-site-request.com"
	token = insert(:oauth_token, app: app)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => unlisted_redirect_uri,
	"state" => "specific_client_state",
	"scope" => "read"
	}
	)

	assert redirected_to(conn) == unlisted_redirect_uri
	end

	test "with existing authentication and OOB `redirect_uri`, redirects to app with `token` and `state` params",
	%{
	app: app,
	conn: conn
	} do
	token = insert(:oauth_token, app: app)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"scope" => "read"
	}
	)

	assert html_response(conn, 200) =~ "Authorization exists"
	end
	end

	describe "POST /oauth/authorize" do
	test "redirects with oauth authorization, " <>
	"granting requested app-supported scopes to both admin- and non-admin users" do
	app_scopes = ["read", "write", "admin", "secret_scope"]
	app = insert(:oauth_app, scopes: app_scopes)
	redirect_uri = OAuthController.default_redirect_uri(app)

	non_admin = insert(:user, is_admin: false)
	admin = insert(:user, is_admin: true)
	scopes_subset = ["read:subscope", "write", "admin"]

	# In case scope param is missing, expecting _all_ app-supported scopes to be granted
	for user <- [non_admin, admin],
	{requested_scopes, expected_scopes} <-
	%{scopes_subset => scopes_subset, nil: app_scopes} do
	conn =
	post(
	build_conn(),
	"/oauth/authorize",
	%{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"scope" => requested_scopes,
	"state" => "statepassed"
	}
	}
	)

	target = redirected_to(conn)
	assert target =~ redirect_uri

	query = URI.parse(target).query \|> URI.query_decoder() \|> Map.new()

	assert %{"state" => "statepassed", "code" => code} = query
	auth = Repo.get_by(Authorization, token: code)
	assert auth
	assert auth.scopes == expected_scopes
	end
	end

	test "redirect to on two-factor auth page" do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	app = insert(:oauth_app, scopes: ["read", "write", "follow"])

	conn =
	build_conn()
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read write",
	"state" => "statepassed"
	}
	})

	result = html_response(conn, 200)

	mfa_token = Repo.get_by(MFA.Token, user_id: user.id)
	assert result =~ app.redirect_uris
	assert result =~ "statepassed"
	assert result =~ mfa_token.token
	assert result =~ "Two-factor authentication"
	end

	test "returns 401 for wrong credentials", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app)
	redirect_uri = OAuthController.default_redirect_uri(app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "wrong",
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"state" => "statepassed",
	"scope" => Enum.join(app.scopes, " ")
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ redirect_uri

	# Error message
	assert result =~ "Invalid Username/Password"
	end

	test "returns 401 for missing scopes" do
	user = insert(:user, is_admin: false)
	app = insert(:oauth_app, scopes: ["read", "write", "admin"])
	redirect_uri = OAuthController.default_redirect_uri(app)

	result =
	build_conn()
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"state" => "statepassed",
	"scope" => ""
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ redirect_uri

	# Error message
	assert result =~ "This action is outside the authorized scopes"
	end

	test "returns 401 for scopes beyond app scopes hierarchy", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])
	redirect_uri = OAuthController.default_redirect_uri(app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => redirect_uri,
	"state" => "statepassed",
	"scope" => "read write follow"
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ redirect_uri

	# Error message
	assert result =~ "This action is outside the authorized scopes"
	end
	end

	describe "POST /oauth/token" do
	test "issues a token for an all-body request" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "me" => ap_id} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == auth.scopes
	assert user.ap_id == ap_id
	end

	test "issues a token for `password` grant_type with valid credentials, with full permissions by default" do
	password = "testpassword"
	user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))

	app = insert(:oauth_app, scopes: ["read", "write"])

	# Note: "scope" param is intentionally omitted
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == app.scopes
	end

	test "issues a mfa token for `password` grant_type, when MFA enabled" do
	password = "testpassword"
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	password_hash: Pbkdf2.hash_pwd_salt(password),
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	app = insert(:oauth_app, scopes: ["read", "write"])

	response =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(403)

	assert match?(
	%{
	"supported_challenge_types" => "totp",
	"mfa_token" => _,
	"error" => "mfa_required"
	},
	response
	)

	token = Repo.get_by(MFA.Token, token: response["mfa_token"])
	assert token.user_id == user.id
	assert token.authorization_id
	end

	test "issues a token for request with HTTP basic auth client credentials" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["scope1", "scope2", "scope3"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["scope1", "scope2"])
	assert auth.scopes == ["scope1", "scope2"]

	app_encoded =
	(URI.encode_www_form(app.client_id) <> ":" <> URI.encode_www_form(app.client_secret))
	\|> Base.encode64()

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic " <> app_encoded)
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => OAuthController.default_redirect_uri(app)
	})

	assert %{"access_token" => token, "scope" => scope} = json_response(conn, 200)

	assert scope == "scope1 scope2"

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == ["scope1", "scope2"]
	end

	test "issue a token for client_credentials grant type" do
	app = insert(:oauth_app, scopes: ["read", "write"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "client_credentials",
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write"
	end

	test "rejects token exchange with invalid client credentials" do
	user = insert(:user)
	app = insert(:oauth_app)

	{:ok, auth} = Authorization.create_authorization(app, user)

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic JTIxOiVGMCU5RiVBNCVCNwo=")
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => OAuthController.default_redirect_uri(app)
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	password = "testpassword"

	{:ok, user} =
	insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
	\|> User.confirmation_changeset(need_confirmation: true)
	\|> User.update_and_set_cache()

	refute Pleroma.User.account_status(user) == :active

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to deactivated user" do
	password = "testpassword"

	user =
	insert(:user,
	password_hash: Pbkdf2.hash_pwd_salt(password),
	deactivated: true
	)

	app = insert(:oauth_app)

	resp =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(403)

	assert resp == %{
	"error" => "Your account is currently disabled",
	"identifier" => "account_is_disabled"
	}
	end

	test "rejects token exchange for user with password_reset_pending set to true" do
	password = "testpassword"

	user =
	insert(:user,
	password_hash: Pbkdf2.hash_pwd_salt(password),
	password_reset_pending: true
	)

	app = insert(:oauth_app, scopes: ["read", "write"])

	resp =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(403)

	assert resp == %{
	"error" => "Password reset is required",
	"identifier" => "password_reset_required"
	}
	end

	test "rejects token exchange for user with confirmation_pending set to true" do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	password = "testpassword"

	user =
	insert(:user,
	password_hash: Pbkdf2.hash_pwd_salt(password),
	confirmation_pending: true
	)

	app = insert(:oauth_app, scopes: ["read", "write"])

	resp =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(403)

	assert resp == %{
	"error" => "Your login is missing a confirmed e-mail address",
	"identifier" => "missing_confirmed_email"
	}
	end

	test "rejects token exchange for valid credentials belonging to an unapproved user" do
	password = "testpassword"

	user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password), approval_pending: true)

	refute Pleroma.User.account_status(user) == :active

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects an invalid authorization code" do
	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => "Imobviouslyinvalid",
	"redirect_uri" => OAuthController.default_redirect_uri(app),
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = json_response(conn, 400)
	refute Map.has_key?(resp, "access_token")
	end
	end

	describe "POST /oauth/token - refresh token" do
	setup do: clear_config([:oauth2, :issue_new_refresh_token])

	test "issues a new access token with keep fresh token" do
	Pleroma.Config.put([:oauth2, :issue_new_refresh_token], true)
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])
	{:ok, token} = Token.exchange_token(app, auth)

	response =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "refresh_token",
	"refresh_token" => token.refresh_token,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(200)

	ap_id = user.ap_id

	assert match?(
	%{
	"scope" => "write",
	"token_type" => "Bearer",
	"expires_in" => 600,
	"access_token" => _,
	"refresh_token" => _,
	"me" => ^ap_id
	},
	response
	)

	refute Repo.get_by(Token, token: token.token)
	new_token = Repo.get_by(Token, token: response["access_token"])
	assert new_token.refresh_token == token.refresh_token
	assert new_token.scopes == auth.scopes
	assert new_token.user_id == user.id
	assert new_token.app_id == app.id
	end

	test "issues a new access token with new fresh token" do
	Pleroma.Config.put([:oauth2, :issue_new_refresh_token], false)
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])
	{:ok, token} = Token.exchange_token(app, auth)

	response =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "refresh_token",
	"refresh_token" => token.refresh_token,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(200)

	ap_id = user.ap_id

	assert match?(
	%{
	"scope" => "write",
	"token_type" => "Bearer",
	"expires_in" => 600,
	"access_token" => _,
	"refresh_token" => _,
	"me" => ^ap_id
	},
	response
	)

	refute Repo.get_by(Token, token: token.token)
	new_token = Repo.get_by(Token, token: response["access_token"])
	refute new_token.refresh_token == token.refresh_token
	assert new_token.scopes == auth.scopes
	assert new_token.user_id == user.id
	assert new_token.app_id == app.id
	end

	test "returns 400 if we try use access token" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])
	{:ok, token} = Token.exchange_token(app, auth)

	response =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "refresh_token",
	"refresh_token" => token.token,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(400)

	assert %{"error" => "Invalid credentials"} == response
	end

	test "returns 400 if refresh_token invalid" do
	app = insert(:oauth_app, scopes: ["read", "write"])

	response =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "refresh_token",
	"refresh_token" => "token.refresh_token",
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(400)

	assert %{"error" => "Invalid credentials"} == response
	end

	test "issues a new token if token expired" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])
	{:ok, token} = Token.exchange_token(app, auth)

	change =
	Ecto.Changeset.change(
	token,
	%{valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), -86_400 * 30)}
	)

	{:ok, access_token} = Repo.update(change)

	response =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "refresh_token",
	"refresh_token" => access_token.refresh_token,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(200)

	ap_id = user.ap_id

	assert match?(
	%{
	"scope" => "write",
	"token_type" => "Bearer",
	"expires_in" => 600,
	"access_token" => _,
	"refresh_token" => _,
	"me" => ^ap_id
	},
	response
	)

	refute Repo.get_by(Token, token: token.token)
	token = Repo.get_by(Token, token: response["access_token"])
	assert token
	assert token.scopes == auth.scopes
	assert token.user_id == user.id
	assert token.app_id == app.id
	end
	end

	describe "POST /oauth/token - bad request" do
	test "returns 500" do
	response =
	build_conn()
	\|> post("/oauth/token", %{})
	\|> json_response(500)

	assert %{"error" => "Bad request"} == response
	end
	end

	describe "POST /oauth/revoke - bad request" do
	test "returns 500" do
	response =
	build_conn()
	\|> post("/oauth/revoke", %{})
	\|> json_response(500)

	assert %{"error" => "Bad request"} == response
	end
	end
	end
	diff --git a/test/pleroma/web/streamer_test.exs b/test/pleroma/web/streamer_test.exs
	index 0d89e01d0..dd210c3b5 100644
	--- a/test/pleroma/web/streamer_test.exs
	+++ b/test/pleroma/web/streamer_test.exs
	@@ -1,777 +1,777 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StreamerTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Conversation.Participation
	alias Pleroma.List
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.StreamerView

	@moduletag needs_streamer: true, capture_log: true

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

	describe "get_topic/_ (unauthenticated)" do
	test "allows public" do
	assert {:ok, "public"} = Streamer.get_topic("public", nil, nil)
	assert {:ok, "public:local"} = Streamer.get_topic("public:local", nil, nil)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", nil, nil)
	assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", nil, nil)
	end

	test "allows instance streams" do
	assert {:ok, "public:remote:lain.com"} =
	Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})

	assert {:ok, "public:remote:media:lain.com"} =
	Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
	end

	test "allows hashtag streams" do
	assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", nil, nil, %{"tag" => "cofe"})
	end

	test "disallows user streams" do
	assert {:error, _} = Streamer.get_topic("user", nil, nil)
	assert {:error, _} = Streamer.get_topic("user:notification", nil, nil)
	assert {:error, _} = Streamer.get_topic("direct", nil, nil)
	end

	test "disallows list streams" do
	assert {:error, _} = Streamer.get_topic("list", nil, nil, %{"list" => 42})
	end
	end

	describe "get_topic/_ (authenticated)" do
	setup do: oauth_access(["read"])

	test "allows public streams (regardless of OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	with oauth_token <- [nil, read_oauth_token] do
	assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
	assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)

	assert {:ok, "public:local:media"} =
	Streamer.get_topic("public:local:media", user, oauth_token)
	end
	end

	test "allows user streams (with proper OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: read_statuses_token} = oauth_access(["read:statuses"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	expected_user_topic = "user:#{user.id}"
	expected_notification_topic = "user:notification:#{user.id}"
	expected_direct_topic = "direct:#{user.id}"
	expected_pleroma_chat_topic = "user:pleroma_chat:#{user.id}"

	for valid_user_token <- [read_oauth_token, read_statuses_token] do
	assert {:ok, ^expected_user_topic} = Streamer.get_topic("user", user, valid_user_token)

	assert {:ok, ^expected_direct_topic} =
	Streamer.get_topic("direct", user, valid_user_token)

	assert {:ok, ^expected_pleroma_chat_topic} =
	Streamer.get_topic("user:pleroma_chat", user, valid_user_token)
	end

	for invalid_user_token <- [read_notifications_token, badly_scoped_token],
	user_topic <- ["user", "direct", "user:pleroma_chat"] do
	assert {:error, :unauthorized} = Streamer.get_topic(user_topic, user, invalid_user_token)
	end

	for valid_notification_token <- [read_oauth_token, read_notifications_token] do
	assert {:ok, ^expected_notification_topic} =
	Streamer.get_topic("user:notification", user, valid_notification_token)
	end

	for invalid_notification_token <- [read_statuses_token, badly_scoped_token] do
	assert {:error, :unauthorized} =
	Streamer.get_topic("user:notification", user, invalid_notification_token)
	end
	end

	test "allows hashtag streams (regardless of OAuth token scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	for oauth_token <- [nil, read_oauth_token] do
	assert {:ok, "hashtag:cofe"} =
	Streamer.get_topic("hashtag", user, oauth_token, %{"tag" => "cofe"})
	end
	end

	test "disallows registering to another user's stream", %{user: user, token: read_oauth_token} do
	another_user = insert(:user)
	assert {:error, _} = Streamer.get_topic("user:#{another_user.id}", user, read_oauth_token)

	assert {:error, _} =
	Streamer.get_topic("user:notification:#{another_user.id}", user, read_oauth_token)

	assert {:error, _} = Streamer.get_topic("direct:#{another_user.id}", user, read_oauth_token)
	end

	test "allows list stream that are owned by the user (with `read` or `read:lists` scopes)", %{
	user: user,
	token: read_oauth_token
	} do
	%{token: read_lists_token} = oauth_access(["read:lists"], user: user)
	%{token: invalid_token} = oauth_access(["irrelevant:scope"], user: user)
	{:ok, list} = List.create("Test", user)

	assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, read_oauth_token)

	for valid_token <- [read_oauth_token, read_lists_token] do
	assert {:ok, _} = Streamer.get_topic("list", user, valid_token, %{"list" => list.id})
	end

	assert {:error, _} = Streamer.get_topic("list", user, invalid_token, %{"list" => list.id})
	end

	test "disallows list stream that are not owned by the user", %{user: user, token: oauth_token} do
	another_user = insert(:user)
	{:ok, list} = List.create("Test", another_user)

	assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, oauth_token)
	assert {:error, _} = Streamer.get_topic("list", user, oauth_token, %{"list" => list.id})
	end
	end

	describe "user streams" do
	setup do
	%{user: user, token: token} = oauth_access(["read"])
	notify = insert(:notification, user: user, activity: build(:note_activity))
	{:ok, %{user: user, notify: notify, token: token}}
	end

	test "it streams the user's post in the 'user' stream", %{user: user, token: oauth_token} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	assert_receive {:render_with_user, _, _, ^activity}
	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it streams boosts of the user in the 'user' stream", %{user: user, token: oauth_token} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, user)

	assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
	refute Streamer.filtered_by_user?(user, announce)
	end

	test "it does not stream announces of the user's own posts in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, other_user)

	assert Streamer.filtered_by_user?(user, announce)
	end

	test "it does stream notifications announces of the user's own posts in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, announce} = CommonAPI.repeat(activity.id, other_user)

	notification =
	Pleroma.Notification
	\|> Repo.get_by(%{user_id: user.id, activity_id: announce.id})
	\|> Repo.preload(:activity)

	refute Streamer.filtered_by_user?(user, notification)
	end

	test "it streams boosts of mastodon user in the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)

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

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	- \|> Poison.decode!()
	+ \|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", user.ap_id)

	{:ok, %Pleroma.Activity{data: _data, local: false} = announce} =
	Pleroma.Web.ActivityPub.Transmogrifier.handle_incoming(data)

	assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
	refute Streamer.filtered_by_user?(user, announce)
	end

	test "it sends notify to in the 'user' stream", %{
	user: user,
	token: oauth_token,
	notify: notify
	} do
	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	Streamer.stream("user", notify)

	assert_receive {:render_with_user, _, _, ^notify}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it sends notify to in the 'user:notification' stream", %{
	user: user,
	token: oauth_token,
	notify: notify
	} do
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	Streamer.stream("user:notification", notify)

	assert_receive {:render_with_user, _, _, ^notify}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it sends chat messages to the 'user:pleroma_chat' stream", %{
	user: user,
	token: oauth_token
	} do
	other_user = insert(:user)

	{:ok, create_activity} =
	CommonAPI.post_chat_message(other_user, user, "hey cirno", idempotency_key: "123")

	object = Object.normalize(create_activity, false)
	chat = Chat.get(user.id, other_user.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	cm_ref = %{cm_ref \| chat: chat, object: object}

	Streamer.get_topic_and_add_socket("user:pleroma_chat", user, oauth_token)
	Streamer.stream("user:pleroma_chat", {user, cm_ref})

	text = StreamerView.render("chat_update.json", %{chat_message_reference: cm_ref})

	assert text =~ "hey cirno"
	assert_receive {:text, ^text}
	end

	test "it sends chat messages to the 'user' stream", %{user: user, token: oauth_token} do
	other_user = insert(:user)

	{:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey cirno")
	object = Object.normalize(create_activity, false)
	chat = Chat.get(user.id, other_user.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	cm_ref = %{cm_ref \| chat: chat, object: object}

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	Streamer.stream("user", {user, cm_ref})

	text = StreamerView.render("chat_update.json", %{chat_message_reference: cm_ref})

	assert text =~ "hey cirno"
	assert_receive {:text, ^text}
	end

	test "it sends chat message notifications to the 'user:notification' stream", %{
	user: user,
	token: oauth_token
	} do
	other_user = insert(:user)

	{:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey")

	notify =
	Repo.get_by(Pleroma.Notification, user_id: user.id, activity_id: create_activity.id)
	\|> Repo.preload(:activity)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	Streamer.stream("user:notification", notify)

	assert_receive {:render_with_user, _, _, ^notify}
	refute Streamer.filtered_by_user?(user, notify)
	end

	test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
	user: user,
	token: oauth_token
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, activity} = CommonAPI.post(user, %{status: ":("})
	{:ok, _} = CommonAPI.favorite(blocked, activity.id)

	refute_receive _
	end

	test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(user, activity)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)

	refute_receive _
	assert Streamer.filtered_by_user?(user, favorite_activity)
	end

	test "it sends favorite to 'user:notification' stream'", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)

	assert_receive {:render_with_user, _, "notification.json", notif}
	assert notif.activity.id == favorite_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end

	test "it doesn't send the 'user:notification' stream' when a domain is blocked", %{
	user: user,
	token: oauth_token
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	{:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)

	refute_receive _
	assert Streamer.filtered_by_user?(user, favorite_activity)
	end

	test "it sends follow activities to the 'user:notification' stream", %{
	user: user,
	token: oauth_token
	} do
	user_url = user.ap_id
	user2 = insert(:user)

	body =
	File.read!("test/fixtures/users_mock/localhost.json")
	\|> String.replace("{{nickname}}", user.nickname)
	\|> Jason.encode!()

	Tesla.Mock.mock_global(fn
	%{method: :get, url: ^user_url} ->
	%Tesla.Env{status: 200, body: body}
	end)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user2, user)

	assert_receive {:render_with_user, _, "notification.json", notif}
	assert notif.activity.id == follow_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end
	end

	describe "public streams" do
	test "it sends to public (authenticated)" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
	assert_receive {:render_with_user, _, _, ^activity}
	refute Streamer.filtered_by_user?(other_user, activity)
	end

	test "it sends to public (unauthenticated)" do
	user = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)

	{:ok, activity} = CommonAPI.post(user, %{status: "Test"})
	activity_id = activity.id
	assert_receive {:text, event}
	assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)

	{:ok, _} = CommonAPI.delete(activity.id, user)
	assert_receive {:text, event}
	assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
	end

	test "handles deletions" do
	%{user: user, token: oauth_token} = oauth_access(["read"])
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})

	Streamer.get_topic_and_add_socket("public", user, oauth_token)

	{:ok, _} = CommonAPI.delete(activity.id, other_user)
	activity_id = activity.id
	assert_receive {:text, event}
	assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
	end
	end

	describe "thread_containment/2" do
	test "it filters to user if recipients invalid and thread containment is enabled" do
	Pleroma.Config.put([:instance, :skip_thread_containment], false)
	author = insert(:user)
	%{user: user, token: oauth_token} = oauth_access(["read"])
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)
	assert_receive {:render_with_user, _, _, ^activity}
	assert Streamer.filtered_by_user?(user, activity)
	end

	test "it sends message if recipients invalid and thread containment is disabled" do
	Pleroma.Config.put([:instance, :skip_thread_containment], true)
	author = insert(:user)
	%{user: user, token: oauth_token} = oauth_access(["read"])
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)

	assert_receive {:render_with_user, _, _, ^activity}
	refute Streamer.filtered_by_user?(user, activity)
	end

	test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
	Pleroma.Config.put([:instance, :skip_thread_containment], false)
	author = insert(:user)
	user = insert(:user, skip_thread_containment: true)
	%{token: oauth_token} = oauth_access(["read"], user: user)
	User.follow(user, author, :follow_accept)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	Streamer.stream("public", activity)

	assert_receive {:render_with_user, _, _, ^activity}
	refute Streamer.filtered_by_user?(user, activity)
	end
	end

	describe "blocks" do
	setup do: oauth_access(["read"])

	test "it filters messages involving blocked users", %{user: user, token: oauth_token} do
	blocked_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked_user)

	Streamer.get_topic_and_add_socket("public", user, oauth_token)
	{:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
	assert_receive {:render_with_user, _, _, ^activity}
	assert Streamer.filtered_by_user?(user, activity)
	end

	test "it filters messages transitively involving blocked users", %{
	user: blocker,
	token: blocker_token
	} do
	blockee = insert(:user)
	friend = insert(:user)

	Streamer.get_topic_and_add_socket("public", blocker, blocker_token)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_one}
	assert Streamer.filtered_by_user?(blocker, activity_one)

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_two}
	assert Streamer.filtered_by_user?(blocker, activity_two)

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	assert_receive {:render_with_user, _, _, ^activity_three}
	assert Streamer.filtered_by_user?(blocker, activity_three)
	end
	end

	describe "lists" do
	setup do: oauth_access(["read"])

	test "it doesn't send unwanted DMs to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)
	user_c = insert(:user)

	{:ok, user_a} = User.follow(user_a, user_b)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, _activity} =
	CommonAPI.post(user_b, %{
	status: "@#{user_c.nickname} Test",
	visibility: "direct"
	})

	refute_receive _
	end

	test "it doesn't send unwanted private posts to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

	{:ok, _activity} =
	CommonAPI.post(user_b, %{
	status: "Test",
	visibility: "private"
	})

	refute_receive _
	end

	test "it sends wanted private posts to list", %{user: user_a, token: user_a_token} do
	user_b = insert(:user)

	{:ok, user_a} = User.follow(user_a, user_b)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})

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

	assert_receive {:render_with_user, _, _, ^activity}
	refute Streamer.filtered_by_user?(user_a, activity)
	end
	end

	describe "muted reblogs" do
	setup do: oauth_access(["read"])

	test "it filters muted reblogs", %{user: user1, token: user1_token} do
	user2 = insert(:user)
	user3 = insert(:user)
	CommonAPI.follow(user1, user2)
	CommonAPI.hide_reblogs(user1, user2)

	{:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})

	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, announce_activity} = CommonAPI.repeat(create_activity.id, user2)
	assert_receive {:render_with_user, _, _, ^announce_activity}
	assert Streamer.filtered_by_user?(user1, announce_activity)
	end

	test "it filters reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user1, user2)
	CommonAPI.hide_reblogs(user1, user2)

	{:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, _announce_activity} = CommonAPI.repeat(create_activity.id, user2)

	assert_receive {:render_with_user, _, "notification.json", notif}
	assert Streamer.filtered_by_user?(user1, notif)
	end

	test "it send non-reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user1, user2)
	CommonAPI.hide_reblogs(user1, user2)

	{:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
	Streamer.get_topic_and_add_socket("user", user1, user1_token)
	{:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id)

	assert_receive {:render_with_user, _, "notification.json", notif}
	refute Streamer.filtered_by_user?(user1, notif)
	end
	end

	describe "muted threads" do
	test "it filters posts from muted threads" do
	user = insert(:user)
	%{user: user2, token: user2_token} = oauth_access(["read"])
	Streamer.get_topic_and_add_socket("user", user2, user2_token)

	{:ok, user2, user, _activity} = CommonAPI.follow(user2, user)
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(user2, activity)

	assert_receive {:render_with_user, _, _, ^activity}
	assert Streamer.filtered_by_user?(user2, activity)
	end
	end

	describe "direct streams" do
	setup do: oauth_access(["read"])

	test "it sends conversation update to the 'direct' stream", %{user: user, token: oauth_token} do
	another_user = insert(:user)

	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

	{:ok, _create_activity} =
	CommonAPI.post(another_user, %{
	status: "hey @#{user.nickname}",
	visibility: "direct"
	})

	assert_receive {:text, received_event}

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	[participation] = Participation.for_user(user)
	assert last_status["pleroma"]["direct_conversation_id"] == participation.id
	end

	test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted",
	%{user: user, token: oauth_token} do
	another_user = insert(:user)

	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

	{:ok, create_activity} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname}",
	visibility: "direct"
	})

	create_activity_id = create_activity.id
	assert_receive {:render_with_user, _, _, ^create_activity}
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)

	{:ok, _} = CommonAPI.delete(create_activity_id, another_user)

	assert_receive {:text, received_event}

	assert %{"event" => "delete", "payload" => ^create_activity_id} =
	Jason.decode!(received_event)

	refute_receive _
	end

	test "it sends conversation update to the 'direct' stream when a message is deleted", %{
	user: user,
	token: oauth_token
	} do
	another_user = insert(:user)
	Streamer.get_topic_and_add_socket("direct", user, oauth_token)

	{:ok, create_activity} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname}",
	visibility: "direct"
	})

	{:ok, create_activity2} =
	CommonAPI.post(another_user, %{
	status: "hi @#{user.nickname} 2",
	in_reply_to_status_id: create_activity.id,
	visibility: "direct"
	})

	assert_receive {:render_with_user, _, _, ^create_activity}
	assert_receive {:render_with_user, _, _, ^create_activity2}
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
	assert_receive {:text, received_conversation1}
	assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)

	{:ok, _} = CommonAPI.delete(create_activity2.id, another_user)

	assert_receive {:text, received_event}
	assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)

	assert_receive {:text, received_event}

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	assert last_status["id"] == to_string(create_activity.id)
	end
	end
	end
	diff --git a/test/support/helpers.ex b/test/support/helpers.ex
	index ecd4b1e18..224034521 100644
	--- a/test/support/helpers.ex
	+++ b/test/support/helpers.ex
	@@ -1,119 +1,119 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Tests.Helpers do
	@moduledoc """
	Helpers for use in tests.
	"""
	alias Pleroma.Config

	defmacro clear_config(config_path) do
	quote do
	clear_config(unquote(config_path)) do
	end
	end
	end

	defmacro clear_config(config_path, do: yield) do
	quote do
	initial_setting = Config.fetch(unquote(config_path))
	unquote(yield)

	on_exit(fn ->
	case initial_setting do
	:error ->
	Config.delete(unquote(config_path))

	{:ok, value} ->
	Config.put(unquote(config_path), value)
	end
	end)

	:ok
	end
	end

	defmacro clear_config(config_path, temp_setting) do
	quote do
	clear_config(unquote(config_path)) do
	Config.put(unquote(config_path), unquote(temp_setting))
	end
	end
	end

	def require_migration(migration_name) do
	[{module, _}] = Code.require_file("#{migration_name}.exs", "priv/repo/migrations")
	{:ok, %{migration: module}}
	end

	defmacro __using__(_opts) do
	quote do
	import Pleroma.Tests.Helpers,
	only: [
	clear_config: 1,
	clear_config: 2
	]

	def to_datetime(%NaiveDateTime{} = naive_datetime) do
	naive_datetime
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.truncate(:second)
	end

	def to_datetime(datetime) when is_binary(datetime) do
	datetime
	\|> NaiveDateTime.from_iso8601!()
	\|> to_datetime()
	end

	def collect_ids(collection) do
	collection
	\|> Enum.map(& &1.id)
	\|> Enum.sort()
	end

	def refresh_record(%{id: id, __struct__: model} = _),
	do: refresh_record(model, %{id: id})

	def refresh_record(model, %{id: id} = _) do
	Pleroma.Repo.get_by(model, id: id)
	end

	# Used for comparing json rendering during tests.
	def render_json(view, template, assigns) do
	assigns = Map.new(assigns)

	view.render(template, assigns)
	- \|> Poison.encode!()
	- \|> Poison.decode!()
	+ \|> Jason.encode!()
	+ \|> Jason.decode!()
	end

	def stringify_keys(nil), do: nil

	def stringify_keys(key) when key in [true, false], do: key
	def stringify_keys(key) when is_atom(key), do: Atom.to_string(key)

	def stringify_keys(map) when is_map(map) do
	map
	\|> Enum.map(fn {k, v} -> {stringify_keys(k), stringify_keys(v)} end)
	\|> Enum.into(%{})
	end

	def stringify_keys([head \| rest] = list) when is_list(list) do
	[stringify_keys(head) \| stringify_keys(rest)]
	end

	def stringify_keys(key), do: key

	defmacro guards_config(config_path) do
	quote do
	initial_setting = Config.get(config_path)

	Config.put(config_path, true)
	on_exit(fn -> Config.put(config_path, initial_setting) end)
	end
	end
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 7:47 AM (8 h, 10 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802825
Default Alt Text: (211 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions