No OneTemporary
Actions

Size

463 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/test/pleroma/integration/mastodon_websocket_test.exs b/test/pleroma/integration/mastodon_websocket_test.exs
	index 88f32762d..47f6f5f76 100644
	--- a/test/pleroma/integration/mastodon_websocket_test.exs
	+++ b/test/pleroma/integration/mastodon_websocket_test.exs
	@@ -1,496 +1,496 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Integration.MastodonWebsocketTest do
	# Needs a streamer, needs to stay synchronous
	use Pleroma.DataCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Integration.WebsocketClient
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth

	@moduletag needs_streamer: true, capture_log: true

	@path Pleroma.Web.Endpoint.url()
	\|> URI.parse()
	\|> Map.put(:scheme, "ws")
	\|> Map.put(:path, "/api/v1/streaming")
	\|> URI.to_string()

	def start_socket(qs \\ nil, headers \\ []) do
	path =
	case qs do
	nil -> @path
	qs -> @path <> qs
	end

	WebsocketClient.start_link(self(), path, headers)
	end

	defp decode_json(json) do
	with {:ok, %{"event" => event, "payload" => payload_text}} <- Jason.decode(json),
	{:ok, payload} <- Jason.decode(payload_text) do
	{:ok, %{"event" => event, "payload" => payload}}
	end
	end

	# Turns atom keys to strings
	defp atom_key_to_string(json) do
	json
	\|> Jason.encode!()
	\|> Jason.decode!()
	end

	test "refuses invalid requests" do
	capture_log(fn ->
	assert {:error, %WebSockex.RequestError{code: 404}} = start_socket("?stream=ncjdk")
	Process.sleep(30)
	end)
	end

	test "requires authentication and a valid token for protected streams" do
	capture_log(fn ->
	assert {:error, %WebSockex.RequestError{code: 401}} =
	start_socket("?stream=user&access_token=aaaaaaaaaaaa")

	assert {:error, %WebSockex.RequestError{code: 401}} = start_socket("?stream=user")
	Process.sleep(30)
	end)
	end

	test "allows unified stream" do
	assert {:ok, _} = start_socket()
	end

	test "allows public streams without authentication" do
	assert {:ok, _} = start_socket("?stream=public")
	assert {:ok, _} = start_socket("?stream=public:local")
	assert {:ok, _} = start_socket("?stream=public:remote&instance=lain.com")
	assert {:ok, _} = start_socket("?stream=hashtag&tag=lain")
	end

	test "receives well formatted events" do
	user = insert(:user)
	{:ok, _} = start_socket("?stream=public")
	{:ok, activity} = CommonAPI.post(user, %{status: "nice echo chamber"})

	assert_receive {:text, raw_json}, 1_000
	assert {:ok, json} = Jason.decode(raw_json)

	assert "update" == json["event"]
	assert json["payload"]
	assert {:ok, json} = Jason.decode(json["payload"])

	view_json =
	Pleroma.Web.MastodonAPI.StatusView.render("show.json", activity: activity, for: nil)
	\|> atom_key_to_string()

	assert json == view_json
	end

	describe "subscribing via WebSocket" do
	test "can subscribe" do
	user = insert(:user)
	{:ok, pid} = start_socket()
	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "public"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)

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

	assert_receive {:text, raw_json}, 1_000
	assert {:ok, json} = Jason.decode(raw_json)

	assert "update" == json["event"]
	assert json["payload"]
	assert {:ok, json} = Jason.decode(json["payload"])

	view_json =
	Pleroma.Web.MastodonAPI.StatusView.render("show.json", activity: activity, for: nil)
	\|> Jason.encode!()
	\|> Jason.decode!()

	assert json == view_json
	end

	test "can subscribe to multiple streams" do
	user = insert(:user)
	{:ok, pid} = start_socket()
	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "public"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)

	WebsocketClient.send_text(
	pid,
	%{type: "subscribe", stream: "hashtag", tag: "mew"} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)

	{:ok, _activity} = CommonAPI.post(user, %{status: "nice echo chamber #mew"})

	assert_receive {:text, raw_json}, 1_000
	assert {:ok, %{"stream" => stream1}} = Jason.decode(raw_json)
	assert_receive {:text, raw_json}, 1_000
	assert {:ok, %{"stream" => stream2}} = Jason.decode(raw_json)

	streams = [stream1, stream2]
	assert ["hashtag", "mew"] in streams
	assert ["public"] in streams
	end

	test "won't double subscribe" do
	user = insert(:user)
	{:ok, pid} = start_socket()
	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "public"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)

	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "public"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "ignored"}
	}} = decode_json(raw_json)

	{:ok, _activity} = CommonAPI.post(user, %{status: "nice echo chamber"})

	assert_receive {:text, _}, 1_000
	refute_receive {:text, _}, 1_000
	end

	test "rejects invalid streams" do
	{:ok, pid} = start_socket()
	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "nonsense"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "error", "error" => "bad_topic"}
	}} = decode_json(raw_json)
	end

	test "can unsubscribe" do
	user = insert(:user)
	{:ok, pid} = start_socket()
	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "public"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)

	WebsocketClient.send_text(pid, %{type: "unsubscribe", stream: "public"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "unsubscribe", "result" => "success"}
	}} = decode_json(raw_json)

	{:ok, _activity} = CommonAPI.post(user, %{status: "nice echo chamber"})
	refute_receive {:text, _}, 1_000
	end
	end

	describe "with a valid user token" do
	setup do
	{:ok, app} =
	Pleroma.Repo.insert(
	OAuth.App.register_changeset(%OAuth.App{}, %{
	client_name: "client",
	scopes: ["read"],
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = OAuth.Authorization.create_authorization(app, user)

	{:ok, token} = OAuth.Token.exchange_token(app, auth)

	%{app: app, user: user, token: token}
	end

	test "accepts valid tokens", state do
	assert {:ok, _} = start_socket("?stream=user&access_token=#{state.token.token}")
	end

	test "accepts the 'user' stream", %{token: token} = _state do
	assert {:ok, _} = start_socket("?stream=user&access_token=#{token.token}")

	capture_log(fn ->
	assert {:error, %WebSockex.RequestError{code: 401}} = start_socket("?stream=user")
	Process.sleep(30)
	end)
	end

	test "accepts the 'user:notification' stream", %{token: token} = _state do
	assert {:ok, _} = start_socket("?stream=user:notification&access_token=#{token.token}")

	capture_log(fn ->
	assert {:error, %WebSockex.RequestError{code: 401}} =
	start_socket("?stream=user:notification")

	Process.sleep(30)
	end)
	end

	test "accepts valid token on Sec-WebSocket-Protocol header", %{token: token} do
	assert {:ok, _} = start_socket("?stream=user", [{"Sec-WebSocket-Protocol", token.token}])

	capture_log(fn ->
	assert {:error, %WebSockex.RequestError{code: 401}} =
	start_socket("?stream=user", [{"Sec-WebSocket-Protocol", "I am a friend"}])

	Process.sleep(30)
	end)
	end

	test "accepts valid token on client-sent event", %{token: token} do
	assert {:ok, pid} = start_socket()

	WebsocketClient.send_text(
	pid,
	%{type: "pleroma:authenticate", token: token.token} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "pleroma:authenticate", "result" => "success"}
	}} = decode_json(raw_json)

	WebsocketClient.send_text(pid, %{type: "subscribe", stream: "user"} \|> Jason.encode!())
	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)
	end

	test "rejects invalid token on client-sent event" do
	assert {:ok, pid} = start_socket()

	WebsocketClient.send_text(
	pid,
	%{type: "pleroma:authenticate", token: "Something else"} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{
	"type" => "pleroma:authenticate",
	"result" => "error",
	"error" => "unauthorized"
	}
	}} = decode_json(raw_json)
	end

	test "rejects new authenticate request if already logged-in", %{token: token} do
	assert {:ok, pid} = start_socket()

	WebsocketClient.send_text(
	pid,
	%{type: "pleroma:authenticate", token: token.token} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "pleroma:authenticate", "result" => "success"}
	}} = decode_json(raw_json)

	WebsocketClient.send_text(
	pid,
	%{type: "pleroma:authenticate", token: "Something else"} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{
	"type" => "pleroma:authenticate",
	"result" => "error",
	"error" => "already_authenticated"
	}
	}} = decode_json(raw_json)
	end

	test "accepts the 'list' stream", %{token: token, user: user} do
	posting_user = insert(:user)

	- {:ok, list} = Pleroma.List.create("test", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "test"}, user)
	Pleroma.List.follow(list, posting_user)

	assert {:ok, _} = start_socket("?stream=list&access_token=#{token.token}&list=#{list.id}")

	assert {:ok, pid} = start_socket("?access_token=#{token.token}")

	WebsocketClient.send_text(
	pid,
	%{type: "subscribe", stream: "list", list: list.id} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "success"}
	}} = decode_json(raw_json)

	WebsocketClient.send_text(
	pid,
	%{type: "subscribe", stream: "list", list: to_string(list.id)} \|> Jason.encode!()
	)

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "pleroma:respond",
	"payload" => %{"type" => "subscribe", "result" => "ignored"}
	}} = decode_json(raw_json)
	end

	test "disconnect when token is revoked", %{app: app, user: user, token: token} do
	assert {:ok, _} = start_socket("?stream=user:notification&access_token=#{token.token}")
	assert {:ok, _} = start_socket("?stream=user&access_token=#{token.token}")

	{:ok, auth} = OAuth.Authorization.create_authorization(app, user)

	{:ok, token2} = OAuth.Token.exchange_token(app, auth)
	assert {:ok, _} = start_socket("?stream=user&access_token=#{token2.token}")

	OAuth.Token.Strategy.Revoke.revoke(token)

	assert_receive {:close, _}
	assert_receive {:close, _}
	refute_receive {:close, _}
	end

	test "receives private statuses", %{user: reading_user, token: token} do
	user = insert(:user)
	CommonAPI.follow(user, reading_user)

	{:ok, _} = start_socket("?stream=user&access_token=#{token.token}")

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

	assert_receive {:text, raw_json}, 1_000
	assert {:ok, json} = Jason.decode(raw_json)

	assert "update" == json["event"]
	assert json["payload"]
	assert {:ok, json} = Jason.decode(json["payload"])

	view_json =
	Pleroma.Web.MastodonAPI.StatusView.render("show.json",
	activity: activity,
	for: reading_user
	)
	\|> Jason.encode!()
	\|> Jason.decode!()

	assert json == view_json
	end

	test "receives edits", %{user: reading_user, token: token} do
	user = insert(:user)
	CommonAPI.follow(user, reading_user)

	{:ok, _} = start_socket("?stream=user&access_token=#{token.token}")

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

	assert_receive {:text, _raw_json}, 1_000

	{:ok, _} = CommonAPI.update(activity, user, %{status: "mew mew", visibility: "private"})

	assert_receive {:text, raw_json}, 1_000

	activity = Pleroma.Activity.normalize(activity)

	view_json =
	Pleroma.Web.MastodonAPI.StatusView.render("show.json",
	activity: activity,
	for: reading_user
	)
	\|> Jason.encode!()
	\|> Jason.decode!()

	assert {:ok, %{"event" => "status.update", "payload" => ^view_json}} = decode_json(raw_json)
	end

	test "receives notifications", %{user: reading_user, token: token} do
	user = insert(:user)
	CommonAPI.follow(user, reading_user)

	{:ok, _} = start_socket("?stream=user:notification&access_token=#{token.token}")

	{:ok, %Pleroma.Activity{id: activity_id} = _activity} =
	CommonAPI.post(user, %{
	status: "nice echo chamber @#{reading_user.nickname}",
	visibility: "private"
	})

	assert_receive {:text, raw_json}, 1_000

	assert {:ok,
	%{
	"event" => "notification",
	"payload" => %{
	"status" => %{
	"id" => ^activity_id
	}
	}
	}} = decode_json(raw_json)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_test.exs b/test/pleroma/web/activity_pub/activity_pub_test.exs
	index 73f53db56..a390cdfa8 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_test.exs
	@@ -1,2791 +1,2791 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Mock
	import Mox
	import Pleroma.Factory
	import Tesla.Mock

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

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

	:ok
	end

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

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

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

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

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

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it returns a user that accepts chat messages" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.accepts_chat_messages
	end

	test "works for guppe actors" do
	user_id = "https://gup.pe/u/bernie2020"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/guppe-actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.name == "Bernie2020 group"
	assert user.actor_type == "Group"
	end

	test "works for bridgy actors" do
	user_id = "https://fed.brid.gy/jk.nipponalba.scot"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/bridgy/actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.actor_type == "Person"

	assert user.avatar == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}],
	"name" => "profile picture"
	}

	assert user.banner == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}],
	"name" => "profile picture"
	}
	end

	test "fetches user featured collection" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user featured collection without embedded object" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/external_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user birthday information from misskey" do
	user_id = "https://misskey.io/@mkljczk"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^user_id
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/birthdays/misskey-user.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.birthday == ~D[2001-02-12]
	end

	test "fetches avatar description" do
	user_id = "https://example.com/users/marcin"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "marcin")
	\|> Jason.decode!()
	\|> Map.delete("featured")
	\|> Map.update("icon", %{}, fn image -> Map.put(image, "name", "image description") end)
	\|> Jason.encode!()

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.avatar["name"] == "image description"
	end
	end

	test "works with avatar/banner href as list" do
	user_id = "https://queef.in/cute_cat"

	user_data =
	"test/fixtures/users_mock/href_as_array.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> Map.delete("featured")
	\|> Jason.encode!()

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

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert length(user.avatar["url"]) == 1
	assert length(user.banner["url"]) == 1

	assert user.avatar["url"] \|> List.first() \|> Map.fetch!("href") ==
	"https://queef.in/storage/profile.webp"

	assert user.banner["url"] \|> List.first() \|> Map.fetch!("href") ==
	"https://queef.in/storage/banner.gif"
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #TEST"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #Reject"})

	{:ok, status_four} = CommonAPI.post(user, %{status: ". #Any1 #any2"})
	{:ok, status_five} = CommonAPI.post(user, %{status: ". #Any2 #any1"})

	for hashtag_timeline_strategy <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_strategy)

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["TEST", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "Essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "REJECT"]
	})

	# Testing that deduplication (if needed) is done on DB (not Ecto) level; :limit is important
	fetch_five =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["ANY1", "any2"],
	limit: 2
	})

	fetch_six =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["any1", "Any2"],
	tag_all: [],
	tag_reject: []
	})

	# Regression test: passing empty lists as filter options shouldn't affect the results
	assert fetch_five == fetch_six

	[fetch_one, fetch_two, fetch_three, fetch_four, fetch_five] =
	Enum.map([fetch_one, fetch_two, fetch_three, fetch_four, fetch_five], fn statuses ->
	Enum.map(statuses, fn s -> Repo.preload(s, object: :hashtags) end)
	end)

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	assert fetch_five == [status_four, status_five]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity, fetch: false)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity, fetch: false)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{type: ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	test "it reverts create", %{user: user} do
	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:ok, _} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	},
	additional: %{
	"expires_at" => DateTime.utc_now()
	}
	})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end

	test "increases quotes count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	quote_data = %{status: "1", quoted_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities for followed hashtags" do
	test "it should return public activities that reference a given hashtag" do
	hashtag = insert(:hashtag, name: "tenshi")
	user = insert(:user)
	other_user = insert(:user)

	{:ok, normally_visible} =
	CommonAPI.post(other_user, %{status: "hello :)", visibility: "public"})

	{:ok, public} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "public"})
	{:ok, _unrelated} = CommonAPI.post(user, %{status: "dai #tensh", visibility: "public"})
	{:ok, unlisted} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "unlisted"})
	{:ok, _private} = CommonAPI.post(user, %{status: "maji #tenshi", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([other_user.follower_address], %{
	followed_hashtags: [hashtag.id]
	})

	assert length(activities) == 3
	normal_id = normally_visible.id
	public_id = public.id
	unlisted_id = unlisted.id
	assert [%{id: ^normal_id}, %{id: ^public_id}, %{id: ^unlisted_id}] = activities
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	insert(:filter, user: user, phrase: "test", hide: true)

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

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	\|> ActivityPub.fetch_activities_for_context(%{user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return activities from deactivated users" do
	_user = insert(:user)
	deactivated = insert(:user)
	active = insert(:user)
	{:ok, activity_one} = CommonAPI.post(deactivated, %{status: "hey!"})
	{:ok, activity_two} = CommonAPI.post(active, %{status: "yay!"})
	{:ok, _updated_user} = User.set_activation(deactivated, false)

	activities = ActivityPub.fetch_activities([], %{})

	refute Enum.member?(activities, activity_one)
	assert Enum.member?(activities, activity_two)
	end

	test "always see your own posts even when they address people you block" do
	user = insert(:user)
	blockee = insert(:user)

	{:ok, _} = User.block(user, blockee)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{blockee.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two, fetch: false)

	data = %{
	"actor" => friend.ap_id,
	"object" => object.data["id"],
	"context" => object.data["context"],
	"type" => "Announce",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [blockee.ap_id]
	}

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(followed_user, user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "see your own posts even when they address actors from blocked domains" do
	user = insert(:user)

	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})

	{:ok, user} = User.block_domain(user, domain)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{domain_user.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker, domain_user} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

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

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "returns your own posts regardless of mute" do
	user = insert(:user)
	muted = insert(:user)

	{:ok, muted_post} = CommonAPI.post(muted, %{status: "Im stupid"})

	{:ok, reply} =
	CommonAPI.post(user, %{status: "I'm muting you", in_reply_to_status_id: muted_post.id})

	{:ok, _} = User.mute(user, muted)

	[activity] = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert activity.id == reply.id
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user, booster} = User.follow(user, booster)

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	test "includes only reblogs on request" do
	user = insert(:user)
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{only_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	insert(:filter, user: user_two, phrase: "cofe", hide: true)
	insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	insert(:filter, user: user_two, phrase: "test", hide: false)

	params = %{
	type: ["Create", "Announce"],
	user: user_two
	}

	{:ok, %{user: user, user_two: user_two, params: params}}
	end

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)

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

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(booster, user)

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

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "strips / from filename", %{test_file: file} do
	file = %Plug.Upload{file \| filename: "../../../../../nested/bad.jpg"}
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	[%{"href" => href}] = object.data["url"]
	assert Regex.match?(~r"/bad.jpg$", href)
	refute Regex.match?(~r"/nested/", href)
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "it sets the default description depending on the configuration", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description])

	clear_config([Pleroma.Upload, :default_description], nil)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == ""

	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"

	clear_config([Pleroma.Upload, :default_description], "unnamed attachment")
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "unnamed attachment"
	end

	test "copies the file to the configured folder", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

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

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

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

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

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

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

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{is_locked: true})

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

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1, user3} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2, user3} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3, user2} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

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

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

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

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "reverts on error",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	maybe_federate: fn _ -> {:error, :reverted} end do
	assert {:error, :reverted} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.aggregate(Object, :count, :id) == 1
	assert Repo.aggregate(Notification, :count, :id) == 0
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	- {:ok, list} = Pleroma.List.create("foo", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "foo"}, user)
	{:ok, list} = Pleroma.List.follow(list, member)

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

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "synchronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/fuser2/followers",
	following_address: "https://remote.org/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"https://remote.org/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"https://remote.org/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/followers/fuser3",
	following_address: "https://remote.org/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"https://remote.org/users/masto_hidden_counters/following" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "https://remote.org/users/masto_hidden_counters/followers"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"https://remote.org/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"https://remote.org/users/masto_hidden_counters/followers" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "https://remote.org/users/masto_hidden_counters/following"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"https://remote.org/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_hidden_counters/followers",
	following_address: "https://remote.org/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(a4.id, user)
	{:ok, _} = CommonAPI.favorite(a3.id, other_user)
	{:ok, _} = CommonAPI.favorite(a3.id, user)
	{:ok, _} = CommonAPI.favorite(a5.id, other_user)
	{:ok, _} = CommonAPI.favorite(a5.id, user)
	{:ok, _} = CommonAPI.favorite(a4.id, other_user)
	{:ok, _} = CommonAPI.favorite(a1.id, user)
	{:ok, _} = CommonAPI.favorite(a1.id, other_user)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

	User.follow(follower, old_user)
	User.follow(follower_move_opted_out, old_user)

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true,
	recipients: recipients
	} = activity

	assert old_user.follower_address in recipients

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end

	test "do not move remote user following relationships" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower_remote = insert(:user, local: false)

	User.follow(follower_remote, old_user)

	assert User.following?(follower_remote, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	assert User.following?(follower_remote, old_user)
	refute User.following?(follower_remote, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

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

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

	results =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

	[result] =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u3} = User.follow(u1, u3)
	{:ok, u3, u1} = User.follow(u3, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

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

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end

	describe "reply filtering" do
	test "`following` still contains announcements by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})

	{:ok, not_followed_to_followed} =
	CommonAPI.post(not_followed, %{
	status: "Also hello",
	in_reply_to_status_id: followed_post.id
	})

	{:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	followed_post_id = followed_post.id
	retoot_id = retoot.id

	assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities

	assert length(activities) == 2
	end

	# This test is skipped because, while this is the desired behavior,
	# there seems to be no good way to achieve it with the method that
	# we currently use for detecting to who a reply is directed.
	# This is a TODO and should be fixed by a later rewrite of the code
	# in question.
	@tag skip: true
	test "`following` still contains self-replies by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	{:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})

	{:ok, _followed_to_not_followed} =
	CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})

	{:ok, _followed_self_reply} =
	CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(activities) == 2
	end
	end

	test "allow fetching of accounts with an empty string name field" do
	Tesla.Mock.mock(fn
	%{method: :get, url: "https://princess.cat/users/mewmew"} ->
	file = File.read!("test/fixtures/mewmew_no_name.json")
	%Tesla.Env{status: 200, body: file, headers: HttpRequestMock.activitypub_object_headers()}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id("https://princess.cat/users/mewmew")
	assert user.name == " "
	end

	test "pin_data_from_featured_collection will ignore unsupported values" do
	assert %{} ==
	ActivityPub.pin_data_from_featured_collection(%{
	"type" => "OrderedCollection",
	"first" => "https://social.example/users/alice/collections/featured?page=true"
	})
	end
	end
	diff --git a/test/pleroma/web/activity_pub/publisher_test.exs b/test/pleroma/web/activity_pub/publisher_test.exs
	index 1f9e0bfe5..c0908655a 100644
	--- a/test/pleroma/web/activity_pub/publisher_test.exs
	+++ b/test/pleroma/web/activity_pub/publisher_test.exs
	@@ -1,605 +1,605 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import Pleroma.Factory
	import Tesla.Mock

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	@as_public "https://www.w3.org/ns/activitystreams#Public"

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

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

	describe "should_federate?/1" do
	test "it returns false when the inbox is nil" do
	refute Publisher.should_federate?(nil, false)
	refute Publisher.should_federate?(nil, true)
	end

	test "it returns true when public is true" do
	assert Publisher.should_federate?(false, true)
	end
	end

	describe "gather_webfinger_links/1" do
	test "it returns links" do
	user = insert(:user)

	expected_links = [
	%{"href" => user.ap_id, "rel" => "self", "type" => "application/activity+json"},
	%{
	"href" => user.ap_id,
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]

	assert expected_links == Publisher.gather_webfinger_links(user)
	end
	end

	describe "determine_inbox/2" do
	test "it returns sharedInbox for messages involving as:Public in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"to" => [@as_public], "cc" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving as:Public in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"cc" => [@as_public], "to" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"cc" => [], "to" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"to" => [], "cc" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	user_two = insert(:user)

	activity = %Activity{
	data: %{"to" => [user_two.ap_id], "cc" => [user.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns inbox for messages involving single recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	activity = %Activity{
	data: %{"to" => [user.ap_id], "cc" => []}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/personal-inbox"
	end
	end

	describe "publish_one/1" do
	test "publish to url with with different ports" do
	inbox80 = "http://42.site/users/nick1/inbox"
	inbox42 = "http://42.site:42/users/nick1/inbox"
	activity = insert(:note_activity)

	mock(fn
	%{method: :post, url: "http://42.site:42/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 42"}}

	%{method: :post, url: "http://42.site/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 80"}}
	end)

	_actor = insert(:user)

	assert {:ok, %{body: "port 42"}} =
	Publisher.prepare_one(%{
	inbox: inbox42,
	activity_id: activity.id,
	unreachable_since: true
	})
	\|> Publisher.publish_one()

	assert {:ok, %{body: "port 80"}} =
	Publisher.prepare_one(%{
	inbox: inbox80,
	activity_id: activity.id,
	unreachable_since: true
	})
	\|> Publisher.publish_one()
	end
	end

	describe "publish/2" do
	test "doesn't publish a non-public activity to quarantined instances." do
	Config.put([:instance, :quarantined_instances], [{"domain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	refute_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id
	}
	}
	)
	end

	test "Publishes a non-public activity to non-quarantined instances." do
	Config.put([:instance, :quarantined_instances], [{"somedomain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id
	}
	},
	priority: 1
	)
	end

	test "Publishes to directly addressed actors with higher priority." do
	note_activity = insert(:direct_note_activity)

	actor = Pleroma.User.get_by_ap_id(note_activity.data["actor"])

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"op" => "publish_one",
	"params" => %{"activity_id" => note_activity.id}
	},
	priority: 0
	)
	end

	test "Publishes with the new actor if prepare_outgoing changes the actor." do
	mock(fn
	%{method: :post, url: "https://domain.com/users/nick1/inbox", body: body} ->
	{:ok, %Tesla.Env{status: 200, body: body}}
	end)

	other_user =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user)
	replaced_actor = insert(:user)

	note_activity =
	insert(:note_activity,
	user: actor,
	data_attrs: %{"to" => [other_user.ap_id]}
	)

	Pleroma.Web.ActivityPub.TransmogrifierMock
	\|> Mox.expect(:prepare_outgoing, fn data ->
	{:ok, Map.put(data, "actor", replaced_actor.ap_id)}
	end)

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id,
	cc: ["https://domain.com/users/nick2/inbox"]
	})

	{:ok, decoded} = Jason.decode(prepared.json)
	assert decoded["actor"] == replaced_actor.ap_id

	{:ok, published} = Publisher.publish_one(prepared)
	sent_activity = Jason.decode!(published.body)
	assert sent_activity["actor"] == replaced_actor.ap_id
	end

	test "publishes an activity with BCC to all relevant peers." do
	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)
	user = insert(:user)

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

	note_activity =
	insert(:note_activity,
	recipients: [follower.ap_id],
	data_attrs: %{"bcc" => [user.ap_id]}
	)

	res = Publisher.publish(actor, note_activity)
	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id
	}
	}
	)
	end

	test "activity with BCC is published to a list member." do
	actor = insert(:user)
	- {:ok, list} = Pleroma.List.create("list", actor)
	+ {:ok, list} = Pleroma.List.create(%{title: "list"}, actor)
	list_member = insert(:user, %{local: false})

	Pleroma.List.follow(list, list_member)

	note_activity =
	insert(:note_activity,
	# recipients: [follower.ap_id],
	data_attrs: %{"bcc" => [list.ap_id]}
	)

	res = Publisher.publish(actor, note_activity)
	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: list_member.inbox,
	activity_id: note_activity.id
	}
	}
	)
	end

	test "publishes a delete activity to peers who signed fetch requests to the create acitvity/object." do
	fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	)

	another_fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain2.com/users/nick1/inbox"
	)

	actor = insert(:user)

	note_activity = insert(:note_activity, user: actor)
	object = Object.normalize(note_activity, fetch: false)

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

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

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

	{:ok, delete} = CommonAPI.delete(note_activity.id, actor)

	res = Publisher.publish(actor, delete)
	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: delete.id
	}
	},
	priority: 1
	)

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain2.com/users/nick1/inbox",
	activity_id: delete.id
	}
	},
	priority: 1
	)
	end
	end

	test "cc in prepared json for a follow request is an empty list" do
	user = insert(:user)
	remote_user = insert(:user, local: false)

	{:ok, _, _, activity} = CommonAPI.follow(remote_user, user)

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"activity_id" => activity.id,
	"op" => "publish"
	}
	)

	ObanHelpers.perform_all()

	expected_params =
	%{
	"activity_id" => activity.id,
	"inbox" => remote_user.inbox,
	"unreachable_since" => nil
	}

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"op" => "publish_one",
	"params" => expected_params
	}
	)

	# params need to be atom keys for Publisher.prepare_one.
	# this is done in the Oban job.
	expected_params = Map.new(expected_params, fn {k, v} -> {String.to_atom(k), v} end)

	%{json: json} = Publisher.prepare_one(expected_params)

	{:ok, decoded} = Jason.decode(json)

	assert decoded["cc"] == []
	end

	test "unlisted activities retain public address in cc" do
	user = insert(:user)

	# simulate unlistd activity by only having
	# public address in cc
	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => [@as_public],
	"to" => [user.follower_address]
	}
	)

	assert @as_public in activity.data["cc"]

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert @as_public in decoded["cc"]

	# maybe we also have another inbox in cc
	# during Publishing
	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => [@as_public],
	"to" => [user.follower_address]
	}
	)

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id,
	cc: ["https://remote.instance/users/someone_else/inbox"]
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert decoded["cc"] == [@as_public, "https://remote.instance/users/someone_else/inbox"]
	end

	test "public address in cc parameter is preserved" do
	user = insert(:user)

	cc_with_public = [@as_public, "https://example.org/users/other"]

	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => cc_with_public,
	"to" => [user.follower_address]
	}
	)

	assert @as_public in activity.data["cc"]

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id,
	cc: cc_with_public
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert cc_with_public == decoded["cc"]
	end

	test "cc parameter is preserved" do
	user = insert(:user)

	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => ["https://example.com/specific/user"],
	"to" => [user.follower_address]
	}
	)

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id,
	cc: ["https://example.com/specific/user"]
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert decoded["cc"] == ["https://example.com/specific/user"]
	end

	describe "prepare_one/1 with reporter anonymization" do
	test "signs with the anonymized actor keys when Transmogrifier changes actor" do
	Pleroma.SignatureMock
	\|> Mox.stub(:signed_date, fn -> Pleroma.Signature.signed_date() end)
	\|> Mox.expect(:sign, fn %Pleroma.User{} = user, _headers ->
	send(self(), {:signed_as, user.ap_id})
	"TESTSIG"
	end)

	placeholder = insert(:user)
	reporter = insert(:user)
	target_account = insert(:user)

	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	{:ok, reported} = CommonAPI.post(target_account, %{status: "content"})
	context = Utils.generate_context_id()

	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported],
	content: "reason"
	})

	_prepared =
	Publisher.prepare_one(%{
	inbox: "http://remote.example/users/alice/inbox",
	activity_id: activity.id
	})

	assert_received {:signed_as, ap_id}
	assert ap_id == placeholder.ap_id
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index b54196a3c..1e9be54ea 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,1119 +1,1119 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert :error = Transmogrifier.handle_incoming(message)

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

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

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

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

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

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

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

	test "it fixes the public scope addressing" do
	insert(:user,
	ap_id: "https://mymath.rocks/endpoints/SYn3cl_N4HAPfPHgo2x37XunLEmhV9LnxCggcYwyec0"
	)

	object =
	"test/fixtures/bovine-bogus-public-note.json"
	\|> File.read!()
	\|> Jason.decode!()

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => "https://mymath.rocks/endpoints/SYn3cl_N4HAPfPHgo2x37XunLEmhV9LnxCggcYwyec0",
	"object" => object
	}

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

	object = Object.normalize(activity, fetch: false)
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in object.data["to"]
	end

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

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

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

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

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

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

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

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

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

	test "doesn't allow remote edits to fake local likes" do
	# as a spot check for no internal fields getting injected
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	local_user = insert(:user)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => [local_user.ap_id]
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0
	end

	test "strips internal fields from history items in edited notes" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	local_user = insert(:user)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => [],
	"like_count" => 0
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [
	Map.merge(create_data["object"], %{
	"likes" => [local_user.ap_id],
	"like_count" => 1,
	"pleroma" => %{"internal_field" => "should_be_stripped"}
	})
	]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	# Check that internal fields are stripped from history items
	history_item = List.first(object.data["formerRepresentations"]["orderedItems"])
	assert history_item["likes"] == []
	assert history_item["like_count"] == 0
	refute Map.has_key?(history_item, "pleroma")
	end

	test "doesn't trip over remote likes in notes" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => %{
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097/likes",
	"totalItems" => 0,
	"type" => "Collection"
	}
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "likes", "totalItems"], 666)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	# in the future this should retain remote likes, but for now:
	assert object.data["like_count"] == 0
	end

	test "doesn't trip over remote likes in polls" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Question",
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "vote!",
	"anyOf" => [
	%{
	"type" => "Note",
	"name" => "a",
	"replies" => %{
	"type" => "Collection",
	"totalItems" => 3
	}
	},
	%{
	"type" => "Note",
	"name" => "b",
	"replies" => %{
	"type" => "Collection",
	"totalItems" => 1
	}
	}
	],
	"likes" => %{
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073/likes",
	"totalItems" => 0,
	"type" => "Collection"
	}
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "vote now!")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "likes", "totalItems"], 666)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "vote!"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "vote now!"
	assert object.data["likes"] == []
	# in the future this should retain remote likes, but for now:
	assert object.data["like_count"] == 0
	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 json-ld context and the conversation property" do
	user = insert(:user)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["generator"])
	assert is_nil(modified["object"]["rules"])
	assert is_nil(modified["object"]["language"])
	assert is_nil(modified["object"]["voters"])
	end

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

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

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

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

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

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

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

	assert modified["directMessage"] == false

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

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

	assert modified["directMessage"] == false

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

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

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	- {:ok, list} = Pleroma.List.create("foo", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "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)

	# This has an inlined object as in ObjectView
	{: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"})

	user_ap_id = user.ap_id
	activity_ap_id = activity.data["id"]
	activity_to = activity.data["to"]
	activity_cc = activity.data["cc"]
	object_ap_id = activity.data["object"]
	object_type = activity.object.data["type"]

	# This does not have an inlined object
	{:ok, modified2} = Transmogrifier.prepare_outgoing(activity.data)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "Listen",
	"actor" => ^user_ap_id,
	"to" => ^activity_to,
	"cc" => ^activity_cc,
	"context" => "http://localhost" <> _,
	"id" => ^activity_ap_id,
	"object" => %{
	"actor" => ^user_ap_id,
	"attributedTo" => ^user_ap_id,
	"id" => ^object_ap_id,
	"type" => ^object_type,
	"to" => ^activity_to,
	"cc" => ^activity_cc
	}
	},
	modified2
	)
	end

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

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

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

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

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

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

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

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

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

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

	test "Updates of Actors are handled" do
	user = insert(:user, local: true)

	changeset = User.update_changeset(user, %{name: "new name"})
	{:ok, unpersisted_user} = Ecto.Changeset.apply_action(changeset, :update)

	updated_object =
	UserView.render("user.json", user: unpersisted_user)
	\|> Map.delete("@context")

	{:ok, update_data, []} = Builder.update(user, updated_object)

	{:ok, activity, _} =
	Pipeline.common_pipeline(update_data,
	local: true,
	user_update_changeset: changeset
	)

	assert {:ok, prepared} = Transmogrifier.prepare_outgoing(activity.data)
	assert prepared["type"] == "Update"
	assert prepared["@context"]
	assert prepared["object"]["type"] == user.actor_type
	end

	test "Correctly handles Undo activities" do
	blocked = insert(:user)
	blocker = insert(:user, local: true)

	blocked_ap_id = blocked.ap_id
	blocker_ap_id = blocker.ap_id

	{:ok, %Activity{} = block_activity} = CommonAPI.block(blocked, blocker)
	{:ok, %Activity{} = undo_activity} = CommonAPI.unblock(blocked, blocker)
	{:ok, data} = Transmogrifier.prepare_outgoing(undo_activity.data)

	block_ap_id = block_activity.data["id"]
	assert is_binary(block_ap_id)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "Undo",
	"id" => "http://localhost" <> _,
	"actor" => ^blocker_ap_id,
	"object" => ^block_ap_id,
	"to" => [^blocked_ap_id],
	"cc" => [],
	"bto" => [],
	"bcc" => []
	},
	data
	)
	end

	test "Correctly handles EmojiReact activities" do
	user = insert(:user, local: true)
	note_activity = insert(:note_activity)

	user_ap_id = user.ap_id
	user_followers = user.follower_address
	note_author = note_activity.data["actor"]
	note_ap_id = note_activity.data["object"]

	assert is_binary(note_author)
	assert is_binary(note_ap_id)

	{:ok, react_activity} = CommonAPI.react_with_emoji(note_activity.id, user, "🐈")
	{:ok, data} = Transmogrifier.prepare_outgoing(react_activity.data)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "EmojiReact",
	"actor" => ^user_ap_id,
	"to" => [^user_followers, ^note_author],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"bto" => [],
	"bcc" => [],
	"content" => "🐈",
	"context" => "2hu",
	"id" => "http://localhost" <> _,
	"object" => ^note_ap_id,
	"tag" => []
	},
	data
	)
	end

	test "EmojiReact custom emoji urls are URI encoded" do
	user = insert(:user, local: true)
	note_activity = insert(:note_activity)

	{:ok, react_activity} = CommonAPI.react_with_emoji(note_activity.id, user, ":dinosaur:")
	{:ok, data} = Transmogrifier.prepare_outgoing(react_activity.data)

	assert length(data["tag"]) == 1

	tag = List.first(data["tag"])
	url = tag["icon"]["url"]

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

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

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

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

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

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

	test "it adds language of the object to its json-ld context" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.object.data)

	assert [_, _, %{"@language" => "pl"}] = modified["@context"]
	end

	test "it adds language of the object to Create activity json-ld context" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert [_, _, %{"@language" => "pl"}] = modified["@context"]
	end

	test "it strips report data" do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, reported_activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	object_ap_id = reported_activity.object.data["id"]

	assert {:ok, activity} =
	Pleroma.Web.ActivityPub.ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

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

	expected_data =
	activity.data
	\|> put_in(["object"], [target_account.ap_id, object_ap_id])
	\|> Map.put("actor", reporter.ap_id)
	\|> Map.merge(Utils.make_json_ld_header())

	assert data == expected_data
	end

	test "it strips report data and anonymize" do
	placeholder = insert(:user)

	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, reported_activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	object_ap_id = reported_activity.object.data["id"]

	assert {:ok, activity} =
	Pleroma.Web.ActivityPub.ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

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

	expected_data =
	activity.data
	\|> put_in(["object"], [target_account.ap_id, object_ap_id])
	\|> Map.put("actor", placeholder.ap_id)
	\|> Map.merge(Utils.make_json_ld_header())

	assert data == expected_data
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	processed = Transmogrifier.prepare_object(original)

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

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

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

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

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

	test "it uses contentMap to specify post language" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	object = Transmogrifier.prepare_object(activity.object.data)

	assert %{"contentMap" => %{"pl" => "Cześć"}} = object
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/visibility_test.exs b/test/pleroma/web/activity_pub/visibility_test.exs
	index fd3dc83a1..f92f2df16 100644
	--- a/test/pleroma/web/activity_pub/visibility_test.exs
	+++ b/test/pleroma/web/activity_pub/visibility_test.exs
	@@ -1,297 +1,297 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.VisibilityTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	setup do
	user = insert(:user)
	mentioned = insert(:user)
	following = insert(:user)
	unrelated = insert(:user)
	{:ok, following, user} = Pleroma.User.follow(following, user)
	- {:ok, list} = Pleroma.List.create("foo", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "foo"}, user)

	Pleroma.List.follow(list, unrelated)

	{:ok, public} =
	CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "public"})

	{:ok, private} =
	CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "private"})

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

	{:ok, unlisted} =
	CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "unlisted"})

	{:ok, list} =
	CommonAPI.post(user, %{
	status: "@#{mentioned.nickname}",
	visibility: "list:#{list.id}"
	})

	%{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	unrelated: unrelated,
	list: list
	}
	end

	test "direct?", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	list: list
	} do
	assert Visibility.direct?(direct)
	refute Visibility.direct?(public)
	refute Visibility.direct?(private)
	refute Visibility.direct?(unlisted)
	assert Visibility.direct?(list)
	end

	test "public?", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	list: list
	} do
	refute Visibility.public?(direct)
	assert Visibility.public?(public)
	refute Visibility.public?(private)
	assert Visibility.public?(unlisted)
	refute Visibility.public?(list)
	end

	test "private?", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	list: list
	} do
	refute Visibility.private?(direct)
	refute Visibility.private?(public)
	assert Visibility.private?(private)
	refute Visibility.private?(unlisted)
	refute Visibility.private?(list)
	end

	test "list?", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	list: list
	} do
	refute Visibility.list?(direct)
	refute Visibility.list?(public)
	refute Visibility.list?(private)
	refute Visibility.list?(unlisted)
	assert Visibility.list?(list)
	end

	test "visible_for_user? Activity", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	unrelated: unrelated,
	list: list
	} do
	# All visible to author

	assert Visibility.visible_for_user?(public, user)
	assert Visibility.visible_for_user?(private, user)
	assert Visibility.visible_for_user?(unlisted, user)
	assert Visibility.visible_for_user?(direct, user)
	assert Visibility.visible_for_user?(list, user)

	# All visible to a mentioned user

	assert Visibility.visible_for_user?(public, mentioned)
	assert Visibility.visible_for_user?(private, mentioned)
	assert Visibility.visible_for_user?(unlisted, mentioned)
	assert Visibility.visible_for_user?(direct, mentioned)
	assert Visibility.visible_for_user?(list, mentioned)

	# DM not visible for just follower

	assert Visibility.visible_for_user?(public, following)
	assert Visibility.visible_for_user?(private, following)
	assert Visibility.visible_for_user?(unlisted, following)
	refute Visibility.visible_for_user?(direct, following)
	refute Visibility.visible_for_user?(list, following)

	# Public and unlisted visible for unrelated user

	assert Visibility.visible_for_user?(public, unrelated)
	assert Visibility.visible_for_user?(unlisted, unrelated)
	refute Visibility.visible_for_user?(private, unrelated)
	refute Visibility.visible_for_user?(direct, unrelated)

	# Public and unlisted visible for unauthenticated

	assert Visibility.visible_for_user?(public, nil)
	assert Visibility.visible_for_user?(unlisted, nil)
	refute Visibility.visible_for_user?(private, nil)
	refute Visibility.visible_for_user?(direct, nil)

	# Visible for a list member
	assert Visibility.visible_for_user?(list, unrelated)
	end

	test "visible_for_user? Object", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	unrelated: unrelated,
	list: list
	} do
	public = Object.normalize(public)
	private = Object.normalize(private)
	unlisted = Object.normalize(unlisted)
	direct = Object.normalize(direct)
	list = Object.normalize(list)

	# All visible to author

	assert Visibility.visible_for_user?(public, user)
	assert Visibility.visible_for_user?(private, user)
	assert Visibility.visible_for_user?(unlisted, user)
	assert Visibility.visible_for_user?(direct, user)
	assert Visibility.visible_for_user?(list, user)

	# All visible to a mentioned user

	assert Visibility.visible_for_user?(public, mentioned)
	assert Visibility.visible_for_user?(private, mentioned)
	assert Visibility.visible_for_user?(unlisted, mentioned)
	assert Visibility.visible_for_user?(direct, mentioned)
	assert Visibility.visible_for_user?(list, mentioned)

	# DM not visible for just follower

	assert Visibility.visible_for_user?(public, following)
	assert Visibility.visible_for_user?(private, following)
	assert Visibility.visible_for_user?(unlisted, following)
	refute Visibility.visible_for_user?(direct, following)
	refute Visibility.visible_for_user?(list, following)

	# Public and unlisted visible for unrelated user

	assert Visibility.visible_for_user?(public, unrelated)
	assert Visibility.visible_for_user?(unlisted, unrelated)
	refute Visibility.visible_for_user?(private, unrelated)
	refute Visibility.visible_for_user?(direct, unrelated)

	# Public and unlisted visible for unauthenticated

	assert Visibility.visible_for_user?(public, nil)
	assert Visibility.visible_for_user?(unlisted, nil)
	refute Visibility.visible_for_user?(private, nil)
	refute Visibility.visible_for_user?(direct, nil)

	# Visible for a list member
	# assert Visibility.visible_for_user?(list, unrelated)
	end

	test "doesn't die when the user doesn't exist",
	%{
	direct: direct,
	user: user
	} do
	Repo.delete(user)
	Pleroma.User.invalidate_cache(user)
	refute Visibility.private?(direct)
	end

	test "get_visibility", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	list: list
	} do
	assert Visibility.get_visibility(public) == "public"
	assert Visibility.get_visibility(private) == "private"
	assert Visibility.get_visibility(direct) == "direct"
	assert Visibility.get_visibility(unlisted) == "unlisted"
	assert Visibility.get_visibility(list) == "list"
	end

	test "get_visibility with directMessage flag" do
	assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
	end

	test "get_visibility with listMessage flag" do
	assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
	end

	describe "entire_thread_visible_for_user?/2" do
	test "returns false if not found activity", %{user: user} do
	refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
	end

	test "returns true if activity hasn't 'Create' type", %{user: user} do
	activity = insert(:like_activity)
	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns false when invalid recipients", %{user: user} do
	author = insert(:user)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["test-user"]}
	)
	)

	refute Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns true if user following to author" do
	author = insert(:user)
	user = insert(:user)
	Pleroma.User.follow(user, author)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => [user.ap_id]}
	)
	)

	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end
	end
	end
	diff --git a/test/pleroma/web/common_api/utils_test.exs b/test/pleroma/web/common_api/utils_test.exs
	index 27b1da1e3..d0cbc3111 100644
	--- a/test/pleroma/web/common_api/utils_test.exs
	+++ b/test/pleroma/web/common_api/utils_test.exs
	@@ -1,691 +1,691 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.UtilsTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.ActivityDraft
	alias Pleroma.Web.CommonAPI.Utils
	use Pleroma.DataCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	@public_address "https://www.w3.org/ns/activitystreams#Public"

	describe "add_attachments/2" do
	setup do
	name =
	"Sakura Mana – Turned on by a Senior OL with a Temptating Tight Skirt-s Full Hipline and Panty Shot- Beautiful Thick Thighs- and Erotic Ass- -2015- -- Oppaitime 8-28-2017 6-50-33 PM.png"

	attachment = %{
	"url" => [%{"href" => URI.encode(name)}]
	}

	%{name: name, attachment: attachment}
	end

	test "it adds attachment links to a given text and attachment set", %{
	name: name,
	attachment: attachment
	} do
	len = 10
	clear_config([Pleroma.Upload, :filename_display_max_length], len)

	expected =
	"<br><a href=\"#{URI.encode(name)}\" class='attachment'>#{String.slice(name, 0..len)}…</a>"

	assert Utils.add_attachments("", [attachment]) == expected
	end

	test "doesn't truncate file name if config for truncate is set to 0", %{
	name: name,
	attachment: attachment
	} do
	clear_config([Pleroma.Upload, :filename_display_max_length], 0)

	expected = "<br><a href=\"#{URI.encode(name)}\" class='attachment'>#{name}</a>"

	assert Utils.add_attachments("", [attachment]) == expected
	end
	end

	describe "it confirms the password given is the current users password" do
	test "incorrect password given" do
	{:ok, user} = UserBuilder.insert()

	assert Utils.confirm_current_password(user, "") == {:error, "Invalid password."}
	end

	test "correct password given" do
	{:ok, user} = UserBuilder.insert()
	assert Utils.confirm_current_password(user, "test") == {:ok, user}
	end
	end

	describe "format_input/3" do
	test "works for bare text/plain" do
	text = "hello world!"
	expected = "hello world!"

	{output, [], []} = Utils.format_input(text, "text/plain")

	assert output == expected

	text = "hello world!\n\nsecond paragraph!"
	expected = "hello world!<br><br>second paragraph!"

	{output, [], []} = Utils.format_input(text, "text/plain")

	assert output == expected
	end

	test "works for bare text/html" do
	text = "<p>hello world!</p>"
	expected = "<p>hello world!</p>"

	{output, [], []} = Utils.format_input(text, "text/html")

	assert output == expected

	text = "<p>hello world!</p><br/>\n<p>second paragraph</p>"
	expected = "<p>hello world!</p><br/>\n<p>second paragraph</p>"

	{output, [], []} = Utils.format_input(text, "text/html")

	assert output == expected
	end

	test "works for bare text/markdown" do
	text = "hello world"
	expected = "<p><strong>hello world</strong></p>"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected

	text = "hello world\n\nanother paragraph"
	expected = "<p><strong>hello world</strong></p><p><em>another paragraph</em></p>"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected

	text = """
	> cool quote

	by someone
	"""

	expected = "<blockquote><p>cool quote</p></blockquote><p>by someone</p>"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected
	end

	test "works for bare text/bbcode" do
	text = "[b]hello world[/b]"
	expected = "<strong>hello world</strong>"

	{output, [], []} = Utils.format_input(text, "text/bbcode")

	assert output == expected

	text = "[b]hello world![/b]\n\nsecond paragraph!"
	expected = "<strong>hello world!</strong><br><br>second paragraph!"

	{output, [], []} = Utils.format_input(text, "text/bbcode")

	assert output == expected

	text = "[b]hello world![/b]\n\n<strong>second paragraph!</strong>"

	expected =
	"<strong>hello world!</strong><br><br><strong>second paragraph!</strong>"

	{output, [], []} = Utils.format_input(text, "text/bbcode")

	assert output == expected
	end

	test "works for text/markdown with mentions" do
	{:ok, user} =
	UserBuilder.insert(%{nickname: "user__test", ap_id: "http://foo.com/user__test"})

	text = "hello world\n\nanother @user__test and @user__test google.com paragraph"

	{output, _, _} = Utils.format_input(text, "text/markdown")

	assert output ==
	~s(<p><strong>hello world</strong></p><p><em>another <span class="h-card"><a class="u-url mention" data-user="#{user.id}" href="http://foo.com/user__test" rel="ugc">@<span>user__test</span></a></span> and <span class="h-card"><a class="u-url mention" data-user="#{user.id}" href="http://foo.com/user__test" rel="ugc">@<span>user__test</span></a></span> <a href="http://google.com" rel="ugc">google.com</a> paragraph</em></p>)
	end
	end

	describe "format_input/3 with markdown" do
	test "Paragraph" do
	code = ~s[Hello\n\nWorld!]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<p>Hello</p><p>World!</p>"
	end

	test "links" do
	code = "https://en.wikipedia.org/wiki/Animal_Crossing_(video_game)"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]

	code = "https://github.com/pragdave/earmark/"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]

	code = "https://github.com/~foo/bar"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]
	end

	test "link with local mention" do
	insert(:user, %{nickname: "lain"})

	code = "https://example.com/@lain"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]
	end

	test "local mentions" do
	mario = insert(:user, %{nickname: "mario"})
	luigi = insert(:user, %{nickname: "luigi"})

	code = "@mario @luigi yo what's up?"
	{result, _, []} = Utils.format_input(code, "text/markdown")

	assert result ==
	~s[<p><span class="h-card"><a class="u-url mention" data-user="#{mario.id}" href="#{mario.ap_id}" rel="ugc">@<span>mario</span></a></span> <span class="h-card"><a class="u-url mention" data-user="#{luigi.id}" href="#{luigi.ap_id}" rel="ugc">@<span>luigi</span></a></span> yo what's up?</p>]
	end

	test "remote mentions" do
	mario = insert(:user, %{nickname: "mario@mushroom.world", local: false})
	luigi = insert(:user, %{nickname: "luigi@mushroom.world", local: false})

	code = "@mario@mushroom.world @luigi@mushroom.world yo what's up?"
	{result, _, []} = Utils.format_input(code, "text/markdown")

	assert result ==
	~s[<p><span class="h-card"><a class="u-url mention" data-user="#{mario.id}" href="#{mario.ap_id}" rel="ugc">@<span>mario</span></a></span> <span class="h-card"><a class="u-url mention" data-user="#{luigi.id}" href="#{luigi.ap_id}" rel="ugc">@<span>luigi</span></a></span> yo what's up?</p>]
	end

	test "raw HTML" do
	code = ~s[<a href="http://example.org/">OwO</a><!-- what's this?-->]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<a href="http://example.org/">OwO</a>]
	end

	test "rulers" do
	code = ~s[before\n\n-----\n\nafter]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<p>before</p><hr/><p>after</p>"
	end

	test "blockquote" do
	code = ~s[> whoms't are you quoting?]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<blockquote><p>whoms't are you quoting?</p></blockquote>"
	end

	test "code" do
	code = ~s[`mix`]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><code class="inline">mix</code></p>]

	code = ~s[``mix``]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><code class="inline">mix</code></p>]

	code = ~s[```\nputs "Hello World"\n```]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<pre><code>puts "Hello World"</code></pre>]

	code = ~s[ <div>\n </div>]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<pre><code><div>\n</div></code></pre>]
	end

	test "lists" do
	code = ~s[- one\n- two\n- three\n- four]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<ul><li>one</li><li>two</li><li>three</li><li>four</li></ul>"

	code = ~s[1. one\n2. two\n3. three\n4. four\n]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<ol><li>one</li><li>two</li><li>three</li><li>four</li></ol>"
	end

	test "delegated renderers" do
	code = ~s[aaaa~]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><em>aaaa~</em></p>]

	code = ~s[aaaa~]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><strong>aaaa~</strong></p>]

	# strikethrough
	code = ~s[~~aaaa~~~]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><del>aaaa</del>~</p>]
	end
	end

	describe "formats date to asctime" do
	test "when date is in ISO 8601 format" do
	date = DateTime.utc_now() \|> DateTime.to_iso8601()

	expected =
	date
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> Calendar.Strftime.strftime!("%a %b %d %H:%M:%S %z %Y")

	assert Utils.date_to_asctime(date) == expected
	end

	test "when date is a binary in wrong format" do
	date = DateTime.utc_now()

	expected = ""

	assert capture_log(fn ->
	assert Utils.date_to_asctime(date) == expected
	end) =~ "Date #{date} in wrong format, must be ISO 8601"
	end

	test "when date is a Unix timestamp" do
	date = DateTime.utc_now() \|> DateTime.to_unix()

	expected = ""

	assert capture_log(fn ->
	assert Utils.date_to_asctime(date) == expected
	end) =~ "Date #{date} in wrong format, must be ISO 8601"
	end

	test "when date is nil" do
	expected = ""

	assert capture_log(fn ->
	assert Utils.date_to_asctime(nil) == expected
	end) =~ "Date in wrong format, must be ISO 8601"
	end

	test "when date is a random string" do
	assert capture_log(fn ->
	assert Utils.date_to_asctime("foo") == ""
	end) =~ "Date foo in wrong format, must be ISO 8601"
	end
	end

	describe "get_to_and_cc" do
	test "for public posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "public"}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert length(cc) == 1

	assert @public_address in to
	assert mentioned_user.ap_id in to
	assert user.follower_address in cc
	end

	test "for public posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "public",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 3
	assert length(cc) == 1

	assert @public_address in to
	assert mentioned_user.ap_id in to
	assert third_user.ap_id in to
	assert user.follower_address in cc
	end

	test "for unlisted posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "unlisted"}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert length(cc) == 1

	assert @public_address in cc
	assert mentioned_user.ap_id in to
	assert user.follower_address in to
	end

	test "for unlisted posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "unlisted",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 3
	assert length(cc) == 1

	assert @public_address in cc
	assert mentioned_user.ap_id in to
	assert third_user.ap_id in to
	assert user.follower_address in to
	end

	test "for private posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "private"}

	{to, cc} = Utils.get_to_and_cc(draft)
	assert length(to) == 2
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	assert user.follower_address in to
	end

	test "for private posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "private",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	assert user.follower_address in to
	end

	test "for direct posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "direct"}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 1
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	end

	test "for direct posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "direct",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 1
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to

	{:ok, direct_activity} = CommonAPI.post(third_user, %{status: "uguu", visibility: "direct"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "direct",
	in_reply_to: direct_activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	assert third_user.ap_id in to
	end
	end

	describe "to_master_date/1" do
	test "removes microseconds from date (NaiveDateTime)" do
	assert Utils.to_masto_date(~N[2015-01-23 23:50:07.123]) == "2015-01-23T23:50:07.000Z"
	end

	test "removes microseconds from date (String)" do
	assert Utils.to_masto_date("2015-01-23T23:50:07.123Z") == "2015-01-23T23:50:07.000Z"
	end

	test "returns empty string when date invalid" do
	assert Utils.to_masto_date("2015-01?23T23:50:07.123Z") == ""
	end
	end

	describe "maybe_notify_mentioned_recipients/2" do
	test "returns recipients when activity is not `Create`" do
	activity = insert(:like_activity)
	assert Utils.maybe_notify_mentioned_recipients(["test"], activity) == ["test"]
	end

	test "returns recipients from tag" do
	user = insert(:user)

	object =
	insert(:note,
	user: user,
	data: %{
	"tag" => [
	%{"type" => "Hashtag"},
	"",
	%{"type" => "Mention", "href" => "https://testing.pleroma.lol/users/lain"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"}
	]
	}
	)

	activity = insert(:note_activity, user: user, note: object)

	assert Utils.maybe_notify_mentioned_recipients(["test"], activity) == [
	"test",
	"https://testing.pleroma.lol/users/lain",
	"https://shitposter.club/user/5381"
	]
	end

	test "returns recipients when object is map" do
	user = insert(:user)
	object = insert(:note, user: user)

	activity =
	insert(:note_activity,
	user: user,
	note: object,
	data_attrs: %{
	"object" => %{
	"tag" => [
	%{"type" => "Hashtag"},
	"",
	%{"type" => "Mention", "href" => "https://testing.pleroma.lol/users/lain"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"}
	]
	}
	}
	)

	Pleroma.Repo.delete(object)

	assert Utils.maybe_notify_mentioned_recipients(["test"], activity) == [
	"test",
	"https://testing.pleroma.lol/users/lain",
	"https://shitposter.club/user/5381"
	]
	end

	test "returns recipients when object not found" do
	user = insert(:user)
	object = insert(:note, user: user)

	activity = insert(:note_activity, user: user, note: object)
	Pleroma.Repo.delete(object)

	obj_url = activity.data["object"]

	Tesla.Mock.mock(fn
	%{method: :get, url: ^obj_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	assert Utils.maybe_notify_mentioned_recipients(["test-test"], activity) == [
	"test-test"
	]
	end
	end

	describe "attachments_from_ids_descs/3" do
	test "returns [] when attachment ids is empty" do
	assert Utils.attachments_from_ids_descs([], "{}", nil) == []
	end

	test "returns list attachments with desc" do
	user = insert(:user)
	object = insert(:attachment, %{user: user})
	desc = Jason.encode!(%{object.id => "test-desc"})

	assert Utils.attachments_from_ids_descs(["#{object.id}", "34"], desc, user) == [
	Map.merge(object.data, %{"name" => "test-desc"})
	]
	end
	end

	describe "attachments_from_ids/2" do
	test "returns attachments with descs" do
	user = insert(:user)
	object = insert(:attachment, %{user: user})
	desc = Jason.encode!(%{object.id => "test-desc"})

	assert Utils.attachments_from_ids(
	%{
	media_ids: ["#{object.id}"],
	descriptions: desc
	},
	user
	) == [
	Map.merge(object.data, %{"name" => "test-desc"})
	]
	end

	test "returns attachments without descs" do
	user = insert(:user)
	object = insert(:attachment, %{user: user})
	assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}, user) == [object.data]
	end

	test "returns [] when not pass media_ids" do
	assert Utils.attachments_from_ids(%{}, nil) == []
	end

	test "returns [] when media_ids not belong to current user" do
	user = insert(:user)
	user2 = insert(:user)

	object = insert(:attachment, %{user: user})

	assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}, user2) == []
	end

	test "checks that the object is of upload type" do
	object = insert(:note)
	assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}, nil) == []
	end
	end

	describe "maybe_add_list_data/3" do
	test "adds list params when found user list" do
	user = insert(:user)
	- {:ok, %Pleroma.List{} = list} = Pleroma.List.create("title", user)
	+ {:ok, %Pleroma.List{} = list} = Pleroma.List.create(%{title: "title"}, user)

	assert Utils.maybe_add_list_data(%{additional: %{}, object: %{}}, user, {:list, list.id}) ==
	%{
	additional: %{"bcc" => [list.ap_id], "listMessage" => list.ap_id},
	object: %{"listMessage" => list.ap_id}
	}
	end

	test "returns original params when list not found" do
	user = insert(:user)
	- {:ok, %Pleroma.List{} = list} = Pleroma.List.create("title", insert(:user))
	+ {:ok, %Pleroma.List{} = list} = Pleroma.List.create(%{title: "title"}, insert(:user))

	assert Utils.maybe_add_list_data(%{additional: %{}, object: %{}}, user, {:list, list.id}) ==
	%{additional: %{}, object: %{}}
	end
	end

	describe "maybe_add_attachments/3" do
	test "returns parsed results when attachment_links is false" do
	assert Utils.maybe_add_attachments(
	{"test", [], ["tags"]},
	[],
	false
	) == {"test", [], ["tags"]}
	end

	test "adds attachments to parsed results" do
	attachment = %{"url" => [%{"href" => "SakuraPM.png"}]}

	assert Utils.maybe_add_attachments(
	{"test", [], ["tags"]},
	[attachment],
	true
	) == {
	"test<br><a href=\"SakuraPM.png\" class='attachment'>SakuraPM.png</a>",
	[],
	["tags"]
	}
	end
	end
	end
	diff --git a/test/pleroma/web/common_api_test.exs b/test/pleroma/web/common_api_test.exs
	index 4eb057712..017fac696 100644
	--- a/test/pleroma/web/common_api_test.exs
	+++ b/test/pleroma/web/common_api_test.exs
	@@ -1,2226 +1,2226 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: false

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Rule
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.PollWorker

	import Ecto.Query, only: [from: 2, where: 3]
	import Mock
	import Mox
	import Pleroma.Factory

	require Pleroma.Activity.Queries
	require Pleroma.Constants

	defp get_announces_of_object(%{data: %{"id" => id}} = _object) do
	Pleroma.Activity.Queries.by_type("Announce")
	\|> Pleroma.Activity.Queries.by_object_id(id)
	\|> Pleroma.Repo.all()
	end

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

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

	:ok
	end

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	describe "posting polls" do
	test "it posts a poll" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "who is the best",
	poll: %{expires_in: 600, options: ["reimu", "marisa"]}
	})

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

	assert object.data["type"] == "Question"
	assert object.data["oneOf"] \|> length() == 2

	assert_enqueued(
	worker: PollWorker,
	args: %{op: "poll_end", activity_id: activity.id},
	scheduled_at: NaiveDateTime.from_iso8601!(object.data["closed"])
	)
	end
	end

	describe "blocking" do
	setup do
	blocker = insert(:user)
	blocked = insert(:user, local: false)
	CommonAPI.follow(blocked, blocker)
	CommonAPI.follow(blocker, blocked)
	CommonAPI.accept_follow_request(blocker, blocked)
	CommonAPI.accept_follow_request(blocked, blocked)
	%{blocker: blocker, blocked: blocked}
	end

	test "it blocks and federates", %{blocker: blocker, blocked: blocked} do
	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert User.get_follow_state(blocker, blocked) == :follow_accept
	refute is_nil(Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked))

	assert {:ok, block} = CommonAPI.block(blocked, blocker)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute User.get_follow_state(blocker, blocked)

	assert %{data: %{"state" => "reject"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(blocker, blocked)

	assert called(Pleroma.Web.Federator.publish(block))
	end
	end

	test "add expiring block", %{blocker: blocker, blocked: blocked} do
	{:ok, _} = CommonAPI.block(blocked, blocker, %{expires_in: 60})
	assert User.blocks?(blocker, blocked)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unblock_user", "blocker_id" => blocker.id, "blocked_id" => blocked.id}

	assert :ok = perform_job(worker, args)
	refute User.blocks?(blocker, blocked)
	end

	test "it blocks and does not federate if outgoing blocks are disabled", %{
	blocker: blocker,
	blocked: blocked
	} do
	clear_config([:instance, :federating], true)
	clear_config([:activitypub, :outgoing_blocks], false)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, block} = CommonAPI.block(blocked, blocker)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute called(Pleroma.Web.Federator.publish(block))
	end
	end
	end

	describe "posting chat messages" do
	setup do: clear_config([:instance, :chat_limit])

	test "it posts a self-chat" do
	author = insert(:user)
	recipient = author

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"remember to buy milk when milk truk arive"
	)

	assert activity.data["type"] == "Create"
	end

	test "it posts a chat message without content but with an attachment" do
	author = insert(:user)
	recipient = insert(:user)

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

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

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ ->
	nil
	end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	nil,
	media_id: upload.id
	)

	notification =
	Notification.for_user_and_activity(recipient, activity)
	\|> Repo.preload(:activity)

	assert called(Pleroma.Web.Push.send(notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	assert activity
	end
	end

	test "it adds html newlines" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"uguu\nuguuu"
	)

	assert other_user.ap_id not in activity.recipients

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

	assert object.data["content"] == "uguu<br/>uguuu"
	end

	test "it linkifies" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"https://example.org is the site of @#{other_user.nickname} #2hu"
	)

	assert other_user.ap_id not in activity.recipients

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

	assert object.data["content"] ==
	"<a href=\"https://example.org\" rel=\"ugc\">https://example.org</a> is the site of <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{other_user.id}\" href=\"#{other_user.ap_id}\" rel=\"ugc\">@<span>#{other_user.nickname}</span></a></span> <a class=\"hashtag\" data-tag=\"2hu\" href=\"http://localhost:4001/tag/2hu\">#2hu</a>"
	end

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

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"a test message <script>alert('uuu')</script> :firefox:"
	)

	assert activity.data["type"] == "Create"
	assert activity.local
	object = Object.normalize(activity, fetch: false)

	assert object.data["type"] == "ChatMessage"
	assert object.data["to"] == [recipient.ap_id]

	assert object.data["content"] ==
	"a test message <script>alert('uuu')</script> :firefox:"

	assert object.data["emoji"] == %{
	"firefox" => "http://localhost:4001/emoji/Firefox.gif"
	}

	assert Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)

	assert :ok == Pleroma.Web.Federator.perform(:publish, activity)
	end

	test "it reject messages over the local limit" do
	clear_config([:instance, :chat_limit], 2)

	author = insert(:user)
	recipient = insert(:user)

	{:error, message} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"123"
	)

	assert message == :content_too_long
	end

	test "it reject messages via MRF" do
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	author = insert(:user)
	recipient = insert(:user)

	assert {:reject, "[KeywordPolicy] Matches with rejected keyword"} ==
	CommonAPI.post_chat_message(author, recipient, "GNO/Linux")
	end

	test "it reject messages with attachments not belonging to user" do
	author = insert(:user)
	not_author = insert(:user)
	recipient = author

	attachment = insert(:attachment, %{user: not_author})

	{:error, message} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"123",
	media_id: attachment.id
	)

	assert message == :forbidden
	end
	end

	describe "unblocking" do
	test "it works even without an existing block activity" do
	blocked = insert(:user)
	blocker = insert(:user)
	User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	assert {:ok, :no_activity} == CommonAPI.unblock(blocked, blocker)
	refute User.blocks?(blocker, blocked)
	end
	end

	describe "deletion" do
	test "it works with pruned objects" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	Object.normalize(post, fetch: false)
	\|> Object.prune()

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows users to delete their posts" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it does not allow a user to delete posts from another user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
	assert Activity.get_by_id(post.id)
	end

	test "it allows privileged users to delete other user's posts" do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "it doesn't allow unprivileged mods or admins to delete other user's posts" do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true, is_admin: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, moderator)
	assert Activity.get_by_id(post.id)
	end

	test "privileged users deleting non-local posts won't federate the delete" do
	clear_config([:instance, :admin_privileges], [:messages_delete])
	# This is the user of the ingested activity
	_user =
	insert(:user,
	local: false,
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: NaiveDateTime.utc_now()
	)

	admin = insert(:user, is_admin: true)

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

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, admin)
	assert delete.local
	refute called(Pleroma.Web.Federator.publish(:_))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows privileged users to delete banned user's posts" do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
	User.set_activation(user, false)

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end
	end

	test "favoriting race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.favorite(activity.id, user)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.favorite(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 20
	end

	test "repeating race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.repeat(activity.id, user)
	end)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 10

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.repeat(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 20
	end

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})

	assert Visibility.direct?(convo_reply)

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

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey",
	visibility: "direct"
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "I don't really like @#{tridi.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	clear_config([:instance, :safe_dm_mentions], true)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	visibility: "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})

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

	assert Object.tags(object) == ["2hu"]
	end

	test "zwnj is treated as word character" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#ساٴين‌س"})

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

	assert Object.tags(object) == ["ساٴين‌س"]
	end

	test "allows lang attribute" do
	user = insert(:user)
	text = ~s{<span lang="en">something</span><p lang="diaetuitech_rpyhpgc">random</p>}

	{:ok, activity} = CommonAPI.post(user, %{status: text, content_type: "text/html"})

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

	assert object.data["content"] == text
	end

	test "double dot in link is allowed" do
	user = insert(:user)
	text = "https://example.to/something..mp3"
	{:ok, activity} = CommonAPI.post(user, %{status: text})

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

	assert object.data["content"] == "<a href=\"#{text}\" rel=\"ugc\">#{text}</a>"
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})

	assert Object.normalize(activity, fetch: false).data["emoji"]["firefox"]
	end

	describe "posting" do
	test "it adds an emoji on an external site" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey :external_emoji:"})

	assert %{"external_emoji" => url} = Object.normalize(activity).data["emoji"]
	assert url == "https://example.com/emoji.png"

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

	assert %{"blank" => url} = Object.normalize(activity).data["emoji"]
	assert url == "#{Pleroma.Web.Endpoint.url()}/emoji/blank.png"
	end

	test "it copies emoji from the subject of the parent post" do
	%Object{} =
	object =
	Object.normalize("https://patch.cx/objects/a399c28e-c821-4820-bc3e-4afeb044c16f",
	fetch: true
	)

	activity = Activity.get_create_by_object_ap_id(object.data["id"])
	user = insert(:user)

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

	assert Object.normalize(reply_activity).data["emoji"]["joker_smile"]
	refute Object.normalize(reply_activity).data["emoji"]["joker_disapprove"]
	end

	test "deactivated users can't post" do
	user = insert(:user, is_active: false)
	assert {:error, _} = CommonAPI.post(user, %{status: "ye"})
	end

	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	to: [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/html"
	})

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

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	assert object.data["source"]["content"] == post
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

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

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

	assert object.data["content"] == "<p><b>2hu</b></p>"
	assert object.data["source"]["content"] == post
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: visibility,
	in_reply_to_status_id: activity.id
	})
	end)
	end

	test "replying with a direct message will NOT auto-add the author of the reply to the recipient list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "I'm stupid"})

	{:ok, open_answer} =
	CommonAPI.post(other_user, %{status: "No ur smart", in_reply_to_status_id: post.id})

	# The OP is implicitly added
	assert user.ap_id in open_answer.recipients

	{:ok, secret_answer} =
	CommonAPI.post(other_user, %{
	status: "lol, that guy really is stupid, right, @#{third_user.nickname}?",
	in_reply_to_status_id: post.id,
	visibility: "direct"
	})

	assert third_user.ap_id in secret_answer.recipients

	# The OP is not added
	refute user.ap_id in secret_answer.recipients
	end

	test "it allows to address a list" do
	user = insert(:user)
	- {:ok, list} = Pleroma.List.create("foo", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "foo"}, user)

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

	assert activity.data["bcc"] == [list.ap_id]
	assert activity.recipients == [list.ap_id, user.ap_id]
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{status: ""})
	end

	test "it validates character limits are correctly enforced" do
	clear_config([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{status: "foobar"})

	assert {:ok, _activity} = CommonAPI.post(user, %{status: "12345"})
	end

	test "it validates media attachment limits are correctly enforced" do
	clear_config([:instance, :max_media_attachments], 4)

	user = insert(:user)

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

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

	assert {:error, "Too many attachments"} =
	CommonAPI.post(user, %{
	status: "",
	media_ids: List.duplicate(upload.id, 5)
	})

	assert {:ok, _activity} =
	CommonAPI.post(user, %{
	status: "",
	media_ids: [upload.id]
	})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)

	assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at: expires_at
	)
	end

	test "it allows quote posting" do
	user = insert(:user)

	{:ok, quoted} = CommonAPI.post(user, %{status: "Hello world"})

	{:ok, quote_post} =
	CommonAPI.post(user, %{status: "nice post", quoted_status_id: quoted.id})

	quoted = Object.normalize(quoted)
	quote_post = Object.normalize(quote_post)

	assert quote_post.data["quoteUrl"] == quoted.data["id"]

	# The OP is not mentioned
	refute quoted.data["actor"] in quote_post.data["to"]
	end

	test "it supports fallback from `quote_id`" do
	user = insert(:user)

	{:ok, quoted} = CommonAPI.post(user, %{status: "Hello world"})
	{:ok, quote_post} = CommonAPI.post(user, %{status: "nice post", quote_id: quoted.id})

	quoted = Object.normalize(quoted)
	quote_post = Object.normalize(quote_post)

	assert quote_post.data["quoteUrl"] == quoted.data["id"]
	end

	test "quote posting with explicit addressing doesn't mention the OP" do
	user = insert(:user)

	{:ok, quoted} = CommonAPI.post(user, %{status: "Hello world"})

	{:ok, quote_post} =
	CommonAPI.post(user, %{status: "nice post", quoted_status_id: quoted.id, to: []})

	assert Object.normalize(quote_post).data["to"] == [Pleroma.Constants.as_public()]
	end

	test "quote posting visibility" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, direct} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
	{:ok, private} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	{:ok, unlisted} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
	{:ok, local} = CommonAPI.post(user, %{status: ".", visibility: "local"})
	{:ok, public} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:error, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: direct.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: private.id})
	{:error, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: private.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: unlisted.id})
	{:ok, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: unlisted.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: local.id})
	{:ok, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: local.id})
	{:ok, _} = CommonAPI.post(user, %{status: "nice", quoted_status_id: public.id})
	{:ok, _} = CommonAPI.post(another_user, %{status: "nice", quoted_status_id: public.id})
	end

	test "it properly mentions punycode domain" do
	user = insert(:user)

	_mentioned_user =
	insert(:user, ap_id: "https://xn--i2raa.com/users/yyy", nickname: "yyy@xn--i2raa.com")

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey @yyy@xn--i2raa.com", content_type: "text/markdown"})

	assert "https://xn--i2raa.com/users/yyy" in Object.normalize(activity).data["to"]
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

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

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	assert unreaction.local

	# On federation, it contains the undone (and deleted) object
	unreaction_with_object = %{
	unreaction
	\| data: Map.put(unreaction.data, "object", reaction.data)
	}

	assert called(Pleroma.Web.Federator.publish(unreaction_with_object))
	end
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, user)
	assert Visibility.public?(announce_activity)
	end

	test "can't repeat a repeat" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, other_user)

	refute match?({:ok, %Activity{}}, CommonAPI.repeat(announce.id, user))
	end

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} =
	CommonAPI.repeat(activity.id, user, %{visibility: "private"})

	assert Visibility.private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)
	end

	test "author can repeat own private statuses" do
	author = insert(:user)
	follower = insert(:user)
	CommonAPI.follow(author, follower)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, author)

	assert Visibility.private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)

	assert Visibility.visible_for_user?(activity, follower)
	assert {:error, :not_found} = CommonAPI.repeat(activity.id, follower)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{data: data}} = CommonAPI.favorite(post_activity.id, user)
	assert data["type"] == "Like"
	assert data["actor"] == user.ap_id
	assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, user)
	{:ok, ^announce} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{}} = CommonAPI.favorite(activity.id, user)
	assert {:ok, :already_liked} = CommonAPI.favorite(activity.id, user)
	end
	end

	describe "pinned statuses" do
	setup do
	clear_config([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "activity not found error", %{user: user} do
	assert {:error, :not_found} = CommonAPI.pin("id", user)
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)
	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How is fediverse today?",
	poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	%{data: %{"id" => object_id}} = Object.normalize(activity)

	user = refresh_record(user)

	assert user.pinned_objects \|> Map.keys() == [object_id]
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, :ownership_error} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity_two.id, user)
	end

	test "only public can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "private status", visibility: "private"})
	{:error, :non_public_error} = CommonAPI.pin(activity.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	id = activity.id

	assert match?({:ok, %{id: ^id}}, CommonAPI.unpin(activity.id, user))

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, _} = CommonAPI.delete(activity.id, user)

	user = refresh_record(user)

	assert user.pinned_objects == %{}
	end

	test "ephemeral activity won't be deleted if was pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "Hello!", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)
	refute Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)

	user = refresh_record(user)
	{:ok, _} = CommonAPI.unpin(activity.id, user)

	# recreates expiration job on unpin
	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)
	end

	test "ephemeral activity deletion job won't be deleted on pinning error", %{
	user: user,
	activity: activity
	} do
	clear_config([:instance, :max_pinned_statuses], 1)

	{:ok, _activity} = CommonAPI.pin(activity.id, user)

	{:ok, activity2} = CommonAPI.post(user, %{status: "another status", expires_in: 601})

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)

	user = refresh_record(user)
	{:error, :pinned_statuses_limit_reached} = CommonAPI.pin(activity2.id, user)

	assert Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity2.id)
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "marks notifications as read after mute" do
	author = insert(:user)
	activity = insert(:note_activity, user: author)

	friend1 = insert(:user)
	friend2 = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(
	friend2,
	%{
	status: "@#{author.nickname} @#{friend1.nickname} test reply",
	in_reply_to_status_id: activity.id
	}
	)

	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, friend2)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, friend1)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	unread_notifications =
	Repo.all(from(n in Notification, where: n.seen == false, where: n.user_id == ^author.id))

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)

	{:ok, _} = CommonAPI.add_mute(activity, author)
	assert CommonAPI.thread_muted?(activity, author)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	read_notifications =
	Repo.all(from(n in Notification, where: n.seen == true, where: n.user_id == ^author.id))

	assert Enum.any?(read_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(activity, user)
	assert CommonAPI.thread_muted?(activity, user)
	end

	test "add expiring mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(activity, user, %{expires_in: 60})
	assert CommonAPI.thread_muted?(activity, user)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_conversation", "user_id" => user.id, "activity_id" => activity.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)
	refute CommonAPI.thread_muted?(activity, user)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(activity, user)
	{:ok, _} = CommonAPI.remove_mute(activity, user)
	refute CommonAPI.thread_muted?(activity, user)
	end

	test "remove mute by ids", %{user: user, activity: activity} do
	CommonAPI.add_mute(activity, user)
	{:ok, _} = CommonAPI.remove_mute(activity.id, user.id)
	refute CommonAPI.thread_muted?(activity, user)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(activity, user)
	{:error, _} = CommonAPI.add_mute(activity, user)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
	activity = Activity.normalize(activity)

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	reported_object_ap_id = activity.object.data["id"]
	comment = "foobar"

	report_data = %{
	account_id: target_user.id,
	comment: comment,
	status_ids: [activity.id]
	}

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

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "doesn't create a report when post is not visible to user" do
	reporter = insert(:user)
	target_user = insert(:user)
	{:ok, post} = CommonAPI.post(target_user, %{status: "Eric", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(post)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(post, reporter)

	# Fails when all status are invisible
	report_data = %{
	account_id: target_user.id,
	comment: "foobar",
	status_ids: [post.id]
	}

	assert {:error, :visibility_error} = CommonAPI.report(reporter, report_data)
	end

	test "doesn't create a report when some posts are not visible to user" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, visible_activity} = CommonAPI.post(target_user, %{status: "cofe"})

	{:ok, invisibile_activity} =
	CommonAPI.post(target_user, %{status: "cawfee", visibility: "private"})

	assert Pleroma.Web.ActivityPub.Visibility.private?(invisibile_activity)
	assert Pleroma.Web.ActivityPub.Visibility.public?(visible_activity)
	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(invisibile_activity, reporter)

	# Fails when some statuses are invisible
	report_data_partial = %{
	account_id: target_user.id,
	comment: "foobar",
	status_ids: [visible_activity.id, invisibile_activity.id]
	}

	assert {:error, :visibility_error} = CommonAPI.report(reporter, report_data_partial)
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)
	object = Object.normalize(activity)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, object_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert object_id == object.data["id"]
	end

	test "updates report state, don't strip when report_strip_status is false" do
	clear_config([:instance, :report_strip_status], false)

	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id, data: report_data}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, reported_activity] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert is_map(reported_activity)

	assert reported_activity["content"] ==
	report_data["object"] \|> Enum.at(1) \|> Map.get("content")
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel very offended!",
	status_ids: [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end

	test "creates a report with provided rules" do
	reporter = insert(:user)
	target_user = insert(:user)

	%{id: rule_id} = Rule.create(%{text: "There are no rules"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id

	report_data = %{
	account_id: target_user.id,
	rule_ids: [rule_id]
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"object" => [^target_ap_id],
	"state" => "open",
	"rules" => [^rule_id]
	}
	} = flag_activity
	end

	test "assigns report to an account" do
	[reporter, target_user] = insert_pair(:user)
	%{id: assigned} = insert(:user)

	{:ok, %Activity{id: report_id}} = CommonAPI.report(reporter, %{account_id: target_user.id})

	{:ok, activity} = CommonAPI.assign_report_to_account(report_id, assigned)

	assert %{data: %{"assigned_account" => ^assigned}} = activity
	end

	test "unassigns report from account" do
	[reporter, target_user] = insert_pair(:user)
	%{id: assigned} = insert(:user)

	{:ok, %Activity{id: report_id}} = CommonAPI.report(reporter, %{account_id: target_user.id})

	CommonAPI.assign_report_to_account(report_id, assigned)
	{:ok, activity} = CommonAPI.assign_report_to_account(report_id, nil)

	refute Map.has_key?(activity.data, "assigned_account")
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muted, muter)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muted, muter)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muted, muter)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "follow/2" do
	test "directly follows a non-locked local user" do
	[follower, followed] = insert_pair(:user)
	{:ok, followed, follower, _} = CommonAPI.follow(followed, follower)

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

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, followed, follower, _} = CommonAPI.follow(followed, follower)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(followed, follower)

	refute User.subscribed_to?(follower, followed)
	end

	test "also unpins a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, followed, follower, _} = CommonAPI.follow(followed, follower)
	{:ok, _endorsement} = User.endorse(follower, followed)

	assert User.endorses?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(followed, follower)

	refute User.endorses?(follower, followed)
	end

	test "cancels a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	assert {:ok, followed, follower, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(followed, follower)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(followed, follower)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true, local: false)

	assert {:ok, followed, follower, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(followed, follower)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(followed, follower)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

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

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

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

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "doesn't create a following relationship if the corresponding follow request doesn't exist" do
	user = insert(:user, is_locked: true)
	not_follower = insert(:user)
	CommonAPI.accept_follow_request(not_follower, user)

	assert Pleroma.FollowingRelationship.following?(not_follower, user) == false
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

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

	{:ok, _, object} = CommonAPI.vote(object, other_user, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(object, other_user, [1])
	end
	end

	describe "listen/2" do
	test "returns a valid activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000
	})

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

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "public"
	end

	test "respects visibility=private" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000,
	visibility: "private"
	})

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

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end

	describe "get_user/1" do
	test "gets user by ap_id" do
	user = insert(:user)
	assert CommonAPI.get_user(user.ap_id) == user
	end

	test "gets user by guessed nickname" do
	user = insert(:user, ap_id: "", nickname: "mario@mushroom.kingdom")
	assert CommonAPI.get_user("https://mushroom.kingdom/users/mario") == user
	end

	test "fallback" do
	assert %User{
	name: "",
	ap_id: "",
	nickname: "erroruser@example.com"
	} = CommonAPI.get_user("")
	end
	end

	describe "with `local` visibility" do
	setup do: clear_config([:instance, :federating], true)

	test "post" do
	user = insert(:user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	assert Visibility.local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "delete" do
	user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"deleted_activity_id" => ^activity_id}} = activity} =
	CommonAPI.delete(activity_id, user)

	assert Visibility.local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "repeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Announce"}} = activity} =
	CommonAPI.repeat(activity_id, user)

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unrepeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	assert {:ok, _} = CommonAPI.repeat(activity_id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unrepeat(activity_id, user)

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "favorite" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Like"}} = activity} =
	CommonAPI.favorite(activity.id, user)

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unfavorite" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, %Activity{}} = CommonAPI.favorite(activity.id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, activity} = CommonAPI.unfavorite(activity.id, user)
	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "react_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "EmojiReact"}} = activity} =
	CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unreact_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, _reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert Visibility.local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end

	describe "update/3" do
	test "updates a post" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1"})

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end

	test "does not change visibility" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1", visibility: "private"})

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Visibility.get_visibility(updated_object) == "private"
	assert Visibility.get_visibility(updated) == "private"
	end

	test "updates a post with emoji" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2 :#{emoji2}:"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated_object.data["emoji"]
	end

	test "updates a post with emoji and federate properly" do
	[{emoji1, _}, {emoji2, _} \| _] = Pleroma.Emoji.get_all()

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "foo1", spoiler_text: "title 1 :#{emoji1}:"})

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

	with_mock Pleroma.Web.Federator,
	publish: fn _p -> nil end do
	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2 :#{emoji2}:"})

	assert updated.data["object"]["content"] == "updated 2 :#{emoji2}:"
	assert %{^emoji2 => _} = updated.data["object"]["emoji"]

	assert called(Pleroma.Web.Federator.publish(updated))
	end
	end

	test "editing a post that copied a remote title with remote emoji should keep that emoji" do
	remote_emoji_uri = "https://remote.org/emoji.png"

	note =
	insert(
	:note,
	data: %{
	"summary" => ":remoteemoji:",
	"emoji" => %{
	"remoteemoji" => remote_emoji_uri
	},
	"tag" => [
	%{
	"type" => "Emoji",
	"name" => "remoteemoji",
	"icon" => %{"url" => remote_emoji_uri}
	}
	]
	}
	)

	note_activity = insert(:note_activity, note: note)

	user = insert(:user)

	{:ok, reply} =
	CommonAPI.post(user, %{
	status: "reply",
	spoiler_text: ":remoteemoji:",
	in_reply_to_id: note_activity.id
	})

	assert reply.object.data["emoji"]["remoteemoji"] == remote_emoji_uri

	{:ok, edit} =
	CommonAPI.update(reply, user, %{status: "reply mew mew", spoiler_text: ":remoteemoji:"})

	edited_note = Pleroma.Object.normalize(edit)

	assert edited_note.data["emoji"]["remoteemoji"] == remote_emoji_uri
	end

	test "respects MRF" do
	user = insert(:user)

	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
	clear_config([:mrf_keyword, :replace], [{"updated", "mewmew"}])

	{:ok, activity} = CommonAPI.post(user, %{status: "foo1", spoiler_text: "updated 1"})
	assert Object.normalize(activity).data["summary"] == "mewmew 1"

	{:ok, updated} = CommonAPI.update(activity, user, %{status: "updated 2"})

	updated_object = Object.normalize(updated)
	assert updated_object.data["content"] == "mewmew 2"
	assert Map.get(updated_object.data, "summary", "") == ""
	assert Map.has_key?(updated_object.data, "updated")
	end
	end

	describe "Group actors" do
	setup do
	poster = insert(:user)
	group = insert(:user, actor_type: "Group")
	other_group = insert(:user, actor_type: "Group")
	%{poster: poster, group: group, other_group: other_group}
	end

	test "it boosts public posts", %{poster: poster, group: group} do
	{:ok, post} = CommonAPI.post(poster, %{status: "hey @#{group.nickname}"})

	announces = get_announces_of_object(post.object)
	assert [_] = announces
	end

	test "it does not boost private posts", %{poster: poster, group: group} do
	{:ok, private_post} =
	CommonAPI.post(poster, %{status: "hey @#{group.nickname}", visibility: "private"})

	assert [] = get_announces_of_object(private_post.object)
	end

	test "remote groups do not boost any posts", %{poster: poster} do
	remote_group =
	insert(:user, actor_type: "Group", local: false, nickname: "remote@example.com")

	{:ok, post} = CommonAPI.post(poster, %{status: "hey @#{User.full_nickname(remote_group)}"})
	assert remote_group.ap_id in post.data["to"]

	announces = get_announces_of_object(post.object)
	assert [] = announces
	end

	test "multiple groups mentioned", %{poster: poster, group: group, other_group: other_group} do
	{:ok, post} =
	CommonAPI.post(poster, %{status: "hey @#{group.nickname} @#{other_group.nickname}"})

	announces = get_announces_of_object(post.object)
	assert [_, _] = announces
	end

	test "it does not boost if group is blocking poster", %{poster: poster, group: group} do
	{:ok, _} = CommonAPI.block(poster, group)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey @#{group.nickname}"})

	announces = get_announces_of_object(post.object)
	assert [] = announces
	end
	end

	describe "Oban jobs are cancelled" do
	setup do
	clear_config([:instance, :federating], true)

	local_user = insert(:user)

	remote_one =
	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	inbox: "https://domain.com/users/nick1/inbox",
	shared_inbox: "https://domain.com/inbox"
	})

	remote_two =
	insert(:user, %{
	local: false,
	nickname: "nick2@example.com",
	ap_id: "https://example.com/users/nick2",
	inbox: "https://example.com/users/nick2/inbox",
	shared_inbox: "https://example.com/inbox"
	})

	%{local_user: local_user, remote_one: remote_one, remote_two: remote_two}
	end

	test "when deleting posts", %{
	local_user: local_user,
	remote_one: remote_one,
	remote_two: remote_two
	} do
	{:ok, _, _} = Pleroma.User.follow(remote_one, local_user)
	{:ok, _, _} = Pleroma.User.follow(remote_two, local_user)

	{:ok, %{id: activity_id} = _activity} =
	CommonAPI.post(local_user, %{status: "Happy Friday everyone!"})

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^activity_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 2

	# The delete should have triggered cancelling the publish_one jobs
	assert {:ok, _delete} = CommonAPI.delete(activity_id, local_user)

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^activity_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 2
	end

	test "when unfavoriting posts", %{
	local_user: local_user,
	remote_one: remote_user
	} do
	{:ok, activity} =
	CommonAPI.post(remote_user, %{status: "I like turtles!"})

	{:ok, %{id: favorite_id} = _favorite} =
	CommonAPI.favorite(activity.id, local_user)

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^favorite_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 1

	# The unfavorite should have triggered cancelling the publish_one jobs
	assert {:ok, _unfavorite} = CommonAPI.unfavorite(activity.id, local_user)

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^favorite_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 1
	end

	test "when unboosting posts", %{
	local_user: local_user,
	remote_one: remote_one,
	remote_two: remote_two
	} do
	{:ok, _, _} = Pleroma.User.follow(remote_one, local_user)
	{:ok, _, _} = Pleroma.User.follow(remote_two, local_user)

	{:ok, activity} =
	CommonAPI.post(remote_one, %{status: "This is an unpleasant post"})

	{:ok, %{id: repeat_id} = _repeat} =
	CommonAPI.repeat(activity.id, local_user)

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^repeat_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 2

	# The unrepeat should have triggered cancelling the publish_one jobs
	assert {:ok, _unfavorite} = CommonAPI.unrepeat(activity.id, local_user)

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^repeat_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 2
	end

	test "when unreacting to posts", %{
	local_user: local_user,
	remote_one: remote_one,
	remote_two: remote_two
	} do
	{:ok, _, _} = Pleroma.User.follow(remote_one, local_user)
	{:ok, _, _} = Pleroma.User.follow(remote_two, local_user)

	{:ok, %{id: activity_id}} =
	CommonAPI.post(remote_one, %{status: "Gang gang!!!!"})

	{:ok, %{id: react_id} = _react} =
	CommonAPI.react_with_emoji(activity_id, local_user, "👍")

	# Generate the publish_one jobs
	ObanHelpers.perform_all()

	publish_one_jobs =
	all_enqueued()
	\|> Enum.filter(fn job ->
	match?(
	%{
	state: "available",
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{"op" => "publish_one", "params" => %{"activity_id" => ^react_id}}
	},
	job
	)
	end)

	assert length(publish_one_jobs) == 2

	# The unreact should have triggered cancelling the publish_one jobs
	assert {:ok, _unreact} = CommonAPI.unreact_with_emoji(activity_id, local_user, "👍")

	# all_enqueued/1 will not return cancelled jobs
	cancelled_jobs =
	Oban.Job
	\|> where([j], j.worker == "Pleroma.Workers.PublisherWorker")
	\|> where([j], j.state == "cancelled")
	\|> where([j], j.args["op"] == "publish_one")
	\|> where([j], j.args["params"]["activity_id"] == ^react_id)
	\|> Pleroma.Repo.all()

	assert length(cancelled_jobs) == 2
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	index ea98b53a8..fb84569bc 100644
	--- a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	@@ -1,2430 +1,2430 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Plugs.SetLocalePlug

	import Pleroma.Factory

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	describe "account fetching" do
	test "works by id" do
	%User{id: user_id} = insert(:user)

	assert %{"id" => ^user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "Can't find user"} =
	build_conn()
	\|> get("/api/v1/accounts/-1")
	\|> json_response_and_validate_schema(404)
	end

	test "relationship field" do
	%{conn: conn, user: user} = oauth_access(["read"])

	other_user = insert(:user)

	response =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert response["id"] == other_user.id
	assert response["pleroma"]["relationship"] == %{}

	assert %{"pleroma" => %{"relationship" => %{"following" => false, "followed_by" => false}}} =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, %{id: other_id}} = User.follow(user, other_user)

	assert %{
	"id" => ^other_id,
	"pleroma" => %{"relationship" => %{"following" => true, "followed_by" => false}}
	} =
	conn
	\|> get("/api/v1/accounts/#{other_id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, _} = User.follow(other_user, user)

	assert %{
	"id" => ^other_id,
	"pleroma" => %{"relationship" => %{"following" => true, "followed_by" => true}}
	} =
	conn
	\|> get("/api/v1/accounts/#{other_id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname" do
	user = insert(:user)

	assert %{"id" => _user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname for remote users" do
	clear_config([:instance, :limit_to_local_content], false)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert %{"id" => _user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "respects limit_to_local_content == :all for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :all)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects limit_to_local_content == :unauthenticated for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)

	user = insert(:user, nickname: "user@example.com", local: false)
	reading_user = insert(:user)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert json_response_and_validate_schema(conn, 404)

	conn =
	build_conn()
	\|> assign(:user, reading_user)
	\|> assign(:token, insert(:oauth_token, user: reading_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == user.id
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	acc_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")
	\|> json_response_and_validate_schema(:ok)

	acc_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")
	\|> json_response_and_validate_schema(:ok)

	acc_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")
	\|> json_response_and_validate_schema(:ok)

	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for internal.fetch actor", %{conn: conn} do
	%User{nickname: "internal.fetch"} = InternalFetchActor.get_actor()

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/internal.fetch")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for deactivated user", %{conn: conn} do
	user = insert(:user, is_active: false)

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(:not_found)
	end
	end

	defp local_and_remote_users do
	local = insert(:user)
	remote = insert(:user, local: false)
	{:ok, local: local, remote: remote}
	end

	describe "user fetching with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user timelines" do
	setup do: oauth_access(["read:statuses"])

	test "works with announces that are just addressed to public", %{conn: conn} do
	user = insert(:user, ap_id: "https://honktest/u/test", local: false)
	other_user = insert(:user)

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

	{:ok, 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"
	}
	\|> ActivityPub.persist(local: false)

	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == announce.id
	end

	test "deactivated user", %{conn: conn} do
	user = insert(:user, is_active: false)

	assert %{"error" => "Can't find user"} ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(:not_found)
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects blocks", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	user_three = insert(:user)

	User.block(user_one, user_two)

	{:ok, activity} = CommonAPI.post(user_two, %{status: "User one sux0rz"})
	{:ok, repeat} = CommonAPI.repeat(activity.id, user_three)

	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Even a blocked user will deliver the full user timeline, there would be
	# no point in looking at a blocked users timeline otherwise
	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Third user's timeline includes the repeat when viewed by unauthenticated user
	resp =
	build_conn()
	\|> get("/api/v1/accounts/#{user_three.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == repeat.id

	# When viewing a third user's timeline, the blocked users' statuses will NOT be shown
	resp = get(conn, "/api/v1/accounts/#{user_three.id}/statuses")

	assert [] == json_response_and_validate_schema(resp, 200)
	end

	test "gets users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, _user_three, _user_one} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	status: "Hi, @#{user_two.nickname}.",
	visibility: "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{status: "private", visibility: "private"})

	# TODO!!!
	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id_one}, %{"id" => id_two}] = resp
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> assign(:token, insert(:oauth_token, user: user_three, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id_one}, %{"id" => id_two}] = resp
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "gets local-only statuses for authenticated users", %{user: _user, conn: conn} do
	user_one = insert(:user)

	{:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!", visibility: "local"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == to_string(activity.id)
	end

	test "gets an users media, excludes reblogs", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])
	other_user = insert(:user)

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

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %{id: image_post_id}} = CommonAPI.post(user, %{status: "cofe", media_ids: [media_id]})

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: other_user.ap_id)

	{:ok, %{id: other_image_post_id}} =
	CommonAPI.post(other_user, %{status: "cofe2", media_ids: [media_id]})

	{:ok, _announce} = CommonAPI.repeat(other_image_post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_media=true")

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(build_conn(), "/api/v1/accounts/#{user.id}/statuses?only_media=1")

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
	{:ok, _} = CommonAPI.repeat(post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=1")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "gets only a user's reblogs", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_reblogs=true")
	assert [%{"id" => ^reblog_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_reblogs=1")
	assert [%{"id" => ^reblog_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "filters user's statuses by a hashtag", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "#hashtag"})
	{:ok, _post} = CommonAPI.post(user, %{status: "hashtag"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "the user views their own timelines and excludes direct messages", %{
	user: user,
	conn: conn
	} do
	{:ok, %{id: public_activity_id}} =
	CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, _direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct")
	assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "muted reactions", %{user: user, conn: conn} do
	user2 = insert(:user)
	User.mute(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user2, "🎅")

	result =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "paginates a user's statuses", %{user: user, conn: conn} do
	{:ok, post_1} = CommonAPI.post(user, %{status: "first post"})
	{:ok, post_2} = CommonAPI.post(user, %{status: "second post"})

	response_1 = get(conn, "/api/v1/accounts/#{user.id}/statuses?limit=1")
	assert [res] = json_response_and_validate_schema(response_1, 200)
	assert res["id"] == post_2.id

	response_2 = get(conn, "/api/v1/accounts/#{user.id}/statuses?limit=1&max_id=#{res["id"]}")
	assert [res] = json_response_and_validate_schema(response_2, 200)
	assert res["id"] == post_1.id

	refute response_1 == response_2
	end
	end

	defp local_and_remote_activities(%{local: local, remote: remote}) do
	insert(:note_activity, user: local)
	insert(:note_activity, user: remote, local: false)

	:ok
	end

	describe "statuses with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "followers" do
	setup do: oauth_access(["read:accounts"])

	test "getting followers", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, %{id: user_id}, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => ^user_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "following with relationship", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, %{id: id}, _} = User.follow(other_user, user)

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{
	"id" => ^id,
	"following" => false,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, _} = User.follow(user, other_user)

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{
	"id" => ^id,
	"following" => true,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "getting followers, hide_followers", %{user: user, conn: conn} do
	other_user = insert(:user, hide_followers: true)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting" do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, pagination", %{user: user, conn: conn} do
	{:ok, %User{id: follower1_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower2_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower3_id}, _user} = :user \|> insert() \|> User.follow(user)

	assert [%{"id" => ^follower3_id}, %{"id" => ^follower2_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get(
	"/api/v1/accounts/#{user.id}/followers?id=#{user.id}&limit=20&max_id=#{follower3_id}"
	)
	\|> json_response_and_validate_schema(200)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3_id}")

	assert [%{"id" => ^follower2_id}] = json_response_and_validate_schema(res_conn, 200)

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{follower2_id}/
	assert link_header =~ ~r/max_id=#{follower2_id}/
	end
	end

	describe "following" do
	setup do: oauth_access(["read:accounts"])

	test "getting following", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "following with relationship", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/following?with_relationships=true")

	id = other_user.id

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{"id" => ^id, "following" => true, "followed_by" => false}
	}
	}
	] = json_response_and_validate_schema(conn, 200)
	end

	test "getting following, hide_follows, other user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, hide_follows, same user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, _other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, pagination", %{user: user, conn: conn} do
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _, _} = User.follow(user, following1)
	{:ok, _, _} = User.follow(user, following2)
	{:ok, _, _} = User.follow(user, following3)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(
	conn,
	"/api/v1/accounts/#{user.id}/following?id=#{user.id}&limit=20&max_id=#{following3.id}"
	)

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(conn, "/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end
	end

	describe "follow/unfollow" do
	setup do: oauth_access(["follow"])

	test "following / unfollowing a user", %{conn: conn} do
	%{id: other_user_id, nickname: other_user_nickname} = insert(:user)

	assert %{"id" => _id, "following" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => _id, "following" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => ^other_user_id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/follows", %{"uri" => other_user_nickname})
	\|> json_response_and_validate_schema(200)
	end

	test "cancelling follow request", %{conn: conn} do
	%{id: other_user_id} = insert(:user, %{is_locked: true})

	assert %{"id" => ^other_user_id, "following" => false, "requested" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(:ok)

	assert %{"id" => ^other_user_id, "following" => false, "requested" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(:ok)
	end

	test "following without reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})

	assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: true})
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: "1"})
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	end

	test "following with reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{followed.id}/follow")

	assert %{"showing_reblogs" => true} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: "0"})
	\|> json_response_and_validate_schema(200)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	end

	test "following with subscription and unsubscribing" do
	%{conn: conn} = oauth_access(["follow"])
	followed = insert(:user)

	assert %{"subscribing" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: true})
	\|> json_response_and_validate_schema(200)

	assert %{"subscribing" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: "1"})
	\|> json_response_and_validate_schema(200)

	assert %{"subscribing" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: false})
	\|> json_response_and_validate_schema(200)
	end

	test "following / unfollowing errors", %{user: user, conn: conn} do
	# self follow
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")

	assert %{"error" => "Can not follow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self unfollow
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self follow via uri
	user = User.get_cached_by_id(user.id)

	assert %{"error" => "Can not follow yourself"} =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => user.nickname})
	\|> json_response_and_validate_schema(400)

	# follow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# follow non existing user via uri
	conn_res =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => "doesntexist"})

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# unfollow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end

	describe "mute/unmute" do
	setup do: oauth_access(["write:mutes"])

	test "with notifications", %{conn: conn} do
	other_user = insert(:user)

	assert %{"id" => _id, "muting" => true, "muting_notifications" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user.id}/mute")
	\|> json_response_and_validate_schema(200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

	test "without notifications", %{conn: conn} do
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"notifications" => "false"})

	assert %{"id" => _id, "muting" => true, "muting_notifications" => false} =
	json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

	test "expiring", %{conn: conn, user: user} do
	other_user = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"duration" => "86400"})

	assert %{"id" => _id, "muting" => true} = json_response_and_validate_schema(conn, 200)

	mute_expires_at = UserRelationship.get_mute_expire_date(user, other_user)

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end

	test "falls back to expires_in", %{conn: conn, user: user} do
	other_user = insert(:user)

	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"expires_in" => "86400"})
	\|> json_response_and_validate_schema(200)

	mute_expires_at = UserRelationship.get_mute_expire_date(user, other_user)

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end
	end

	describe "pinned statuses" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
	%{conn: conn} = oauth_access(["read:statuses"], user: user)

	[conn: conn, user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: %{id: activity_id}} do
	{:ok, _} = CommonAPI.pin(activity_id, user)

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "view pinned private statuses" do
	user = insert(:user)
	reader = insert(:user)

	# Create a private status and pin it
	{:ok, %{id: activity_id} = activity} =
	CommonAPI.post(user, %{status: "psst", visibility: "private"})

	%{data: %{"id" => object_ap_id}} = Object.normalize(activity)
	{:ok, _} = User.add_pinned_object_id(user, object_ap_id)

	%{conn: conn} = oauth_access(["read:statuses"], user: reader)

	# A non-follower can't see the pinned status
	assert [] ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)

	# Follow the user, then the pinned status can be seen
	CommonAPI.follow(user, reader)
	ObanHelpers.perform_all()

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end

	test "blocking / unblocking a user" do
	%{conn: conn} = oauth_access(["follow"])
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response_and_validate_schema(conn, 200)
	end

	describe "create account by app" do
	setup do
	valid_params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	}

	[valid_params: valid_params]
	end

	test "registers and logs in without :account_activation_required / :account_approval_required",
	%{conn: conn} do
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: 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 follow"

	clear_config([User, :email_blacklist], ["example.org"])

	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true
	}

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", params)

	assert %{"error" => "{\"email\":[\"Invalid email\"]}"} =
	json_response_and_validate_schema(conn, 400)

	clear_config([User, :email_blacklist], [])

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", params)

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => ^scope,
	"token_type" => "Bearer"
	} = json_response_and_validate_schema(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	user = Repo.preload(token_from_db, :user).user

	assert user
	assert user.is_confirmed
	assert user.is_approved
	end

	test "registers but does not log in with :account_activation_required", %{conn: conn} do
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :account_approval_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: 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 follow"

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true
	})

	response = json_response_and_validate_schema(conn, 200)
	assert %{"identifier" => "missing_confirmed_email"} = response
	refute response["access_token"]
	refute response["token_type"]

	user = Repo.get_by(User, email: "lain@example.org")
	refute user.is_confirmed
	end

	test "registers but does not log in with :account_approval_required", %{conn: conn} do
	clear_config([:instance, :account_approval_required], true)
	clear_config([:instance, :account_activation_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: 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 follow"

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true,
	reason: "I'm a cool dude, bro"
	})

	response = json_response_and_validate_schema(conn, 200)
	assert %{"identifier" => "awaiting_approval"} = response
	refute response["access_token"]
	refute response["token_type"]

	user = Repo.get_by(User, email: "lain@example.org")

	refute user.is_approved
	assert user.registration_reason == "I'm a cool dude, bro"
	end

	test "returns error when user already registered", %{conn: conn, valid_params: valid_params} do
	_user = insert(:user, email: "lain@example.org")
	app_token = insert(:oauth_token, user: nil)

	res =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts", valid_params)

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"email\":[\"has already been taken\"]}"
	}
	end

	test "returns bad_request if missing required params", %{
	conn: conn,
	valid_params: valid_params
	} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")

	res = post(conn, "/api/v1/accounts", valid_params)
	assert json_response_and_validate_schema(res, 200)

	[{127, 0, 0, 1}, {127, 0, 0, 2}, {127, 0, 0, 3}, {127, 0, 0, 4}]
	\|> Stream.zip(Map.delete(valid_params, :email))
	\|> Enum.each(fn {ip, {attr, _}} ->
	res =
	conn
	\|> Map.put(:remote_ip, ip)
	\|> post("/api/v1/accounts", Map.delete(valid_params, attr))
	\|> json_response_and_validate_schema(400)

	assert res == %{
	"error" => "Missing field: #{attr}.",
	"errors" => [
	%{
	"message" => "Missing field: #{attr}",
	"source" => %{"pointer" => "/#{attr}"},
	"title" => "Invalid value"
	}
	]
	}
	end)
	end

	test "returns bad_request if missing email params when :account_activation_required is enabled",
	%{conn: conn, valid_params: valid_params} do
	clear_config([:instance, :account_activation_required], true)

	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")

	res =
	conn
	\|> Map.put(:remote_ip, {127, 0, 0, 5})
	\|> post("/api/v1/accounts", Map.delete(valid_params, :email))

	assert json_response_and_validate_schema(res, 400) ==
	%{"error" => "Missing parameter: email"}

	res =
	conn
	\|> Map.put(:remote_ip, {127, 0, 0, 6})
	\|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"email\":[\"can't be blank\"]}"
	}
	end

	test "allow registration without an email", %{conn: conn, valid_params: valid_params} do
	app_token = insert(:oauth_token, user: nil)
	conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)

	res =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> Map.put(:remote_ip, {127, 0, 0, 7})
	\|> post("/api/v1/accounts", Map.delete(valid_params, :email))

	assert json_response_and_validate_schema(res, 200)
	end

	test "allow registration with an empty email", %{conn: conn, valid_params: valid_params} do
	app_token = insert(:oauth_token, user: nil)
	conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)

	res =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> Map.put(:remote_ip, {127, 0, 0, 8})
	\|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))

	assert json_response_and_validate_schema(res, 200)
	end

	test "returns forbidden if token is invalid", %{conn: conn, valid_params: valid_params} do
	res =
	conn
	\|> put_req_header("authorization", "Bearer " <> "invalid-token")
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts", valid_params)

	assert json_response_and_validate_schema(res, 403) == %{"error" => "Invalid credentials"}
	end

	test "registration from trusted app" do
	clear_config([Pleroma.Captcha, :enabled], true)
	app = insert(:oauth_app, trusted: true, scopes: ["read", "write", "follow", "push"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "client_credentials",
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "token_type" => "Bearer"} = json_response(conn, 200)

	response =
	build_conn()
	\|> Plug.Conn.put_req_header("authorization", "Bearer " <> token)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts", %{
	nickname: "nickname",
	agreement: true,
	email: "email@example.com",
	fullname: "Lain",
	username: "Lain",
	password: "some_password",
	confirm: "some_password"
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"access_token" => access_token,
	"created_at" => _,
	"scope" => "read write follow push",
	"token_type" => "Bearer"
	} = response

	response =
	build_conn()
	\|> Plug.Conn.put_req_header("authorization", "Bearer " <> access_token)
	\|> get("/api/v1/accounts/verify_credentials")
	\|> json_response_and_validate_schema(200)

	assert %{
	"acct" => "Lain",
	"bot" => false,
	"display_name" => "Lain",
	"follow_requests_count" => 0,
	"followers_count" => 0,
	"following_count" => 0,
	"locked" => false,
	"note" => "",
	"source" => %{
	"fields" => [],
	"note" => "",
	"pleroma" => %{
	"actor_type" => "Person",
	"discoverable" => false,
	"no_rich_text" => false,
	"show_role" => true
	},
	"privacy" => "public",
	"sensitive" => false
	},
	"statuses_count" => 0,
	"username" => "Lain"
	} = response
	end
	end

	describe "create account by app / rate limit" do
	setup do: clear_config([:rate_limit, :app_account_creation], {10_000, 2})

	test "respects rate limit setting", %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> Map.put(:remote_ip, {15, 15, 15, 15})
	\|> put_req_header("content-type", "multipart/form-data")

	for i <- 1..2 do
	conn =
	conn
	\|> post("/api/v1/accounts", %{
	username: "#{i}lain",
	email: "#{i}lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => _scope,
	"token_type" => "Bearer"
	} = json_response_and_validate_schema(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	token_from_db = Repo.preload(token_from_db, :user)
	assert token_from_db.user
	end

	conn =
	post(conn, "/api/v1/accounts", %{
	username: "6lain",
	email: "6lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	assert json_response_and_validate_schema(conn, :too_many_requests) == %{
	"error" => "Throttled"
	}
	end
	end

	describe "create account with enabled captcha" do
	setup %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")

	[conn: conn]
	end

	setup do: clear_config([Pleroma.Captcha, :enabled], true)

	test "creates an account and returns 200 if captcha is valid", %{conn: conn} do
	%{token: token, answer_data: answer_data} = Pleroma.Captcha.new()

	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: Pleroma.Captcha.Mock.solution(),
	captcha_token: token,
	captcha_answer_data: answer_data
	}

	assert %{
	"access_token" => access_token,
	"created_at" => _,
	"scope" => "read",
	"token_type" => "Bearer"
	} =
	conn
	\|> post("/api/v1/accounts", params)
	\|> json_response_and_validate_schema(:ok)

	assert Token \|> Repo.get_by(token: access_token) \|> Repo.preload(:user) \|> Map.get(:user)
	end

	test "returns 400 if any captcha field is not provided", %{conn: conn} do
	captcha_fields = [:captcha_solution, :captcha_token, :captcha_answer_data]

	valid_params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: "xx",
	captcha_token: "xx",
	captcha_answer_data: "xx"
	}

	for field <- captcha_fields do
	expected = %{
	"error" => "{\"captcha\":[\"Invalid CAPTCHA (Missing parameter: #{field})\"]}"
	}

	assert expected ==
	conn
	\|> post("/api/v1/accounts", Map.delete(valid_params, field))
	\|> json_response_and_validate_schema(:bad_request)
	end
	end

	test "returns an error if captcha is invalid", %{conn: conn} do
	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: "cofe",
	captcha_token: "cofe",
	captcha_answer_data: "cofe"
	}

	assert %{"error" => "{\"captcha\":[\"Invalid answer data\"]}"} ==
	conn
	\|> post("/api/v1/accounts", params)
	\|> json_response_and_validate_schema(:bad_request)
	end
	end

	describe "create account with required birth date" do
	setup %{conn: conn} do
	clear_config([:instance, :birthday_required], true)
	clear_config([:instance, :birthday_min_age], 18 * 365)

	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")

	[conn: conn]
	end

	test "creates an account if provided valid birth date", %{conn: conn} do
	birthday =
	Date.utc_today()
	\|> Date.add(-19 * 365)
	\|> Date.to_string()

	params = %{
	username: "mkljczk",
	email: "mkljczk@example.org",
	password: "dupa.8",
	agreement: true,
	birthday: birthday
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)
	end

	test "returns an error if missing birth date", %{conn: conn} do
	params = %{
	username: "mkljczk",
	email: "mkljczk@example.org",
	password: "dupa.8",
	agreement: true
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"birthday\":[\"can't be blank\"]}"
	}
	end
	end

	describe "create account with language" do
	setup %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_cookie(SetLocalePlug.frontend_language_cookie_name(), "zh-Hans")
	\|> SetLocalePlug.call([])

	[conn: conn]
	end

	test "creates an account with language parameter", %{conn: conn} do
	params = %{
	username: "foo",
	email: "foo@example.org",
	password: "dupa.8",
	agreement: true,
	language: "ru"
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "ru"} = Pleroma.User.get_by_nickname("foo")
	end

	test "language parameter should be normalized", %{conn: conn} do
	params = %{
	username: "foo",
	email: "foo@example.org",
	password: "dupa.8",
	agreement: true,
	language: "ru-RU"
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "ru_RU"} = Pleroma.User.get_by_nickname("foo")
	end

	test "creating an account without language parameter should fallback to cookie/header language",
	%{conn: conn} do
	params = %{
	username: "foo2",
	email: "foo2@example.org",
	password: "dupa.8",
	agreement: true
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "zh_Hans"} = Pleroma.User.get_by_nickname("foo2")
	end
	end

	describe "GET /api/v1/accounts/:id/lists - account_lists" do
	test "returns lists to which the account belongs" do
	%{user: user, conn: conn} = oauth_access(["read:lists"])
	other_user = insert(:user)
	- assert {:ok, %Pleroma.List{id: _list_id} = list} = Pleroma.List.create("Test List", user)
	+ assert {:ok, %Pleroma.List{id: _list_id} = list} = Pleroma.List.create(%{title: "Test List"}, user)
	{:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)

	assert [%{"id" => _list_id, "title" => "Test List"}] =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/lists")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "verify_credentials" do
	test "verify_credentials" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	[notification \| _] =
	insert_list(7, :notification, user: user, activity: insert(:note_activity))

	Pleroma.Notification.set_read_up_to(user, notification.id)
	conn = get(conn, "/api/v1/accounts/verify_credentials")

	response = json_response_and_validate_schema(conn, 200)

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = response
	assert response["pleroma"]["chat_token"]
	assert response["pleroma"]["unread_notifications_count"] == 6
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted" do
	user = insert(:user, default_scope: "unlisted")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end

	test "locked accounts" do
	user = insert(:user, default_scope: "private")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end
	end

	describe "user relationships" do
	setup do: oauth_access(["read:follows"])

	test "returns the relationships for the current user", %{user: user, conn: conn} do
	%{id: other_user_id} = other_user = insert(:user)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id[]=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns an empty list on a bad request", %{conn: conn} do
	conn = get(conn, "/api/v1/accounts/relationships", %{})

	assert [] = json_response_and_validate_schema(conn, 200)
	end
	end

	test "getting a list of mutes" do
	%{user: user, conn: conn} = oauth_access(["read:mutes"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user1)
	{:ok, _user_relationships} = User.mute(user, other_user2)
	{:ok, _user_relationships} = User.mute(user, other_user3, %{duration: 24 * 60 * 60})

	date =
	DateTime.utc_now()
	\|> DateTime.add(24 * 60 * 60)
	\|> DateTime.truncate(:second)
	\|> DateTime.to_iso8601()

	result =
	conn
	\|> get("/api/v1/mutes")
	\|> json_response_and_validate_schema(200)

	assert [id3, id2, id1] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> get("/api/v1/mutes?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> get("/api/v1/mutes")
	\|> json_response_and_validate_schema(200)

	assert [
	%{"id" => ^id3, "mute_expires_at" => ^date},
	%{"id" => ^id2, "mute_expires_at" => nil},
	%{"id" => ^id1, "mute_expires_at" => nil}
	] = result
	end

	test "list of mutes with with_relationships parameter" do
	%{user: user, conn: conn} = oauth_access(["read:mutes"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _, _} = User.follow(other_user1, user)
	{:ok, _, _} = User.follow(other_user2, user)
	{:ok, _, _} = User.follow(other_user3, user)

	{:ok, _} = User.mute(user, other_user1)
	{:ok, _} = User.mute(user, other_user2)
	{:ok, _} = User.mute(user, other_user3, %{duration: 24 * 60 * 60})

	date =
	DateTime.utc_now()
	\|> DateTime.add(24 * 60 * 60)
	\|> DateTime.truncate(:second)
	\|> DateTime.to_iso8601()

	assert [
	%{
	"id" => ^id3,
	"pleroma" => %{
	"relationship" => %{
	"muting" => true,
	"mute_expires_at" => ^date,
	"followed_by" => true
	}
	}
	},
	%{
	"id" => ^id2,
	"pleroma" => %{
	"relationship" => %{
	"muting" => true,
	"mute_expires_at" => nil,
	"followed_by" => true
	}
	}
	},
	%{
	"id" => ^id1,
	"pleroma" => %{
	"relationship" => %{
	"muting" => true,
	"mute_expires_at" => nil,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/mutes?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "getting a list of blocks" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationship} = User.block(user, other_user1)
	{:ok, _user_relationship} = User.block(user, other_user3)
	{:ok, _user_relationship} = User.block(user, other_user2, %{duration: 24 * 60 * 60})

	date =
	DateTime.utc_now()
	\|> DateTime.add(24 * 60 * 60)
	\|> DateTime.truncate(:second)
	\|> DateTime.to_iso8601()

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")
	\|> json_response_and_validate_schema(200)

	assert [id3, id2, id1] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	conn_res =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=2")

	next_url =
	~r{<.+?(?<link>/api[^>]+)>; rel=\"next\"}
	\|> Regex.named_captures(get_resp_header(conn_res, "link") \|> Enum.at(0))
	\|> Map.get("link")

	result =
	conn_res
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get(next_url)
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("api/v1/blocks")
	\|> json_response_and_validate_schema(200)

	assert [
	%{"id" => ^id3, "block_expires_at" => nil},
	%{"id" => ^id2, "block_expires_at" => ^date},
	%{"id" => ^id1, "block_expires_at" => nil}
	] = result
	end

	test "list of blocks with with_relationships parameter" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _, _} = User.follow(other_user1, user)
	{:ok, _, _} = User.follow(other_user2, user)
	{:ok, _, _} = User.follow(other_user3, user)

	{:ok, _} = User.block(user, other_user1)
	{:ok, _} = User.block(user, other_user2)
	{:ok, _} = User.block(user, other_user3, %{duration: 24 * 60 * 60})

	date =
	DateTime.utc_now()
	\|> DateTime.add(24 * 60 * 60)
	\|> DateTime.truncate(:second)
	\|> DateTime.to_iso8601()

	assert [
	%{
	"id" => ^id3,
	"pleroma" => %{
	"relationship" => %{
	"blocking" => true,
	"block_expires_at" => ^date,
	"followed_by" => false
	}
	}
	},
	%{
	"id" => ^id2,
	"pleroma" => %{
	"relationship" => %{
	"blocking" => true,
	"block_expires_at" => nil,
	"followed_by" => false
	}
	}
	},
	%{
	"id" => ^id1,
	"pleroma" => %{
	"relationship" => %{
	"blocking" => true,
	"block_expires_at" => nil,
	"followed_by" => false
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/blocks?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "account lookup", %{conn: conn} do
	%{nickname: acct} = insert(:user, %{nickname: "nickname"})
	%{nickname: acct_two} = insert(:user, %{nickname: "nickname@notlocaldoma.in"})

	result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=#{acct}")
	\|> json_response_and_validate_schema(200)

	assert %{"acct" => ^acct} = result

	result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=#{acct_two}")
	\|> json_response_and_validate_schema(200)

	assert %{"acct" => ^acct_two} = result

	_result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=unexisting_nickname")
	\|> json_response_and_validate_schema(404)
	end

	test "account lookup with restrict unauthenticated profiles for local" do
	clear_config([:restrict_unauthenticated, :profiles, :local], true)

	user = insert(:user, local: true)
	reading_user = insert(:user)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/lookup?acct=#{user.nickname}")

	assert json_response_and_validate_schema(conn, 401)

	conn =
	build_conn()
	\|> assign(:user, reading_user)
	\|> assign(:token, insert(:oauth_token, user: reading_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/lookup?acct=#{user.nickname}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == user.id
	end

	test "account lookup with restrict unauthenticated profiles for remote" do
	clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	user = insert(:user, nickname: "user@example.com", local: false)
	reading_user = insert(:user)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/lookup?acct=#{user.nickname}")

	assert json_response_and_validate_schema(conn, 401)

	conn =
	build_conn()
	\|> assign(:user, reading_user)
	\|> assign(:token, insert(:oauth_token, user: reading_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/lookup?acct=#{user.nickname}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == user.id
	end

	test "create a note on a user" do
	%{conn: conn} = oauth_access(["write:accounts", "read:follows"])
	other_user = insert(:user)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{other_user.id}/note", %{
	"comment" => "Example note"
	})

	assert [%{"note" => "Example note"}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	describe "account endorsements" do
	setup do: oauth_access(["read:accounts", "write:accounts", "write:follows"])

	setup do: clear_config([:instance, :max_endorsed_users], 1)

	test "pin account", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)

	CommonAPI.follow(other_user1, user)

	assert %{"id" => ^id1, "endorsed" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{id1}/endorse")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "unpin account", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)

	CommonAPI.follow(other_user1, user)
	User.endorse(user, other_user1)

	assert %{"id" => ^id1, "endorsed" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{id1}/unendorse")
	\|> json_response_and_validate_schema(200)

	assert [] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "max pinned accounts", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)

	CommonAPI.follow(other_user1, user)
	CommonAPI.follow(other_user2, user)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{id1}/endorse")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "You have already pinned the maximum number of users"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{id2}/endorse")
	\|> json_response_and_validate_schema(400)
	end

	test "returns a list of pinned accounts", %{conn: conn} do
	clear_config([:instance, :max_endorsed_users], 3)

	%{id: id1} = user1 = insert(:user)
	%{id: id2} = user2 = insert(:user)
	%{id: id3} = user3 = insert(:user)

	CommonAPI.follow(user2, user1)
	CommonAPI.follow(user3, user1)

	User.endorse(user1, user2)
	User.endorse(user1, user3)

	[%{"id" => ^id2}, %{"id" => ^id3}] =
	conn
	\|> get("/api/v1/accounts/#{id1}/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "returns 404 error when specified user is not exist", %{conn: conn} do
	conn = get(conn, "/api/v1/accounts/test/endorsements")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "familiar followers" do
	setup do: oauth_access(["read:follows"])

	test "fetch user familiar followers", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [%{"id" => ^id1}], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns empty array if followers are hidden", %{user: user, conn: conn} do
	other_user1 = insert(:user, hide_follows: true)
	%{id: id2} = other_user2 = insert(:user)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end

	test "it respects hide_followers", %{user: user, conn: conn} do
	other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user, hide_followers: true)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "remove from followers" do
	setup do: oauth_access(["follow"])

	test "removing user from followers", %{conn: conn, user: user} do
	%{id: other_user_id} = other_user = insert(:user)

	CommonAPI.follow(user, other_user)

	assert %{"id" => ^other_user_id, "followed_by" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/remove_from_followers")
	\|> json_response_and_validate_schema(200)

	refute User.following?(other_user, user)
	end

	test "removing remote user from followers", %{conn: conn, user: user} do
	%{id: other_user_id} = other_user = insert(:user, local: false)

	CommonAPI.follow(user, other_user)

	assert User.following?(other_user, user)

	assert %{"id" => ^other_user_id, "followed_by" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/remove_from_followers")
	\|> json_response_and_validate_schema(200)

	refute User.following?(other_user, user)
	end

	test "removing user from followers errors", %{user: user, conn: conn} do
	# self remove
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/remove_from_followers")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# remove non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/remove_from_followers")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
	index 9808652d2..b685f4ff8 100644
	--- a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
	@@ -1,1093 +1,1093 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import Tesla.Mock

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

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

	describe "home" do
	setup do: oauth_access(["read:statuses"])

	test "does NOT embed account/pleroma/relationship in statuses", %{
	user: user,
	conn: conn
	} do
	other_user = insert(:user)

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

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert Enum.all?(response, fn n ->
	get_in(n, ["account", "pleroma", "relationship"]) == %{}
	end)
	end

	test "the home timeline when the direct messages are excluded", %{user: user, conn: conn} do
	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

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

	conn = get(conn, "/api/v1/timelines/home?exclude_visibilities[]=direct")

	assert status_ids = json_response_and_validate_schema(conn, :ok) \|> Enum.map(& &1["id"])
	assert public_activity.id in status_ids
	assert unlisted_activity.id in status_ids
	assert private_activity.id in status_ids
	refute direct_activity.id in status_ids
	end

	test "muted emotions", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "filtering", %{conn: conn, user: user} do
	local_user = insert(:user)
	{:ok, user, local_user} = User.follow(user, local_user)
	{:ok, local_activity} = CommonAPI.post(local_user, %{status: "Status"})
	with_media = create_with_media_activity(local_user)

	remote_user = insert(:user, local: false)
	{:ok, _user, remote_user} = User.follow(user, remote_user)
	remote_activity = create_remote_activity(remote_user)

	without_filter_ids =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in without_filter_ids
	assert remote_activity.id in without_filter_ids
	assert with_media.id in without_filter_ids

	only_local_ids =
	conn
	\|> get("/api/v1/timelines/home?local=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in only_local_ids
	refute remote_activity.id in only_local_ids
	assert with_media.id in only_local_ids

	only_local_media_ids =
	conn
	\|> get("/api/v1/timelines/home?local=true&only_media=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in only_local_media_ids
	refute remote_activity.id in only_local_media_ids
	assert with_media.id in only_local_media_ids

	remote_ids =
	conn
	\|> get("/api/v1/timelines/home?remote=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in remote_ids
	assert remote_activity.id in remote_ids
	refute with_media.id in remote_ids

	assert conn
	\|> get("/api/v1/timelines/home?remote=true&only_media=true")
	\|> json_response_and_validate_schema(200) == []

	assert conn
	\|> get("/api/v1/timelines/home?remote=true&local=true")
	\|> json_response_and_validate_schema(200) == []
	end

	test "the home timeline excludes posts from users in exclusive lists", %{
	user: user,
	conn: conn
	} do
	other_user1 = insert(:user)
	other_user2 = insert(:user)

	{:ok, user, other_user1} = User.follow(user, other_user1)
	{:ok, user, other_user2} = User.follow(user, other_user2)

	{:ok, list} = Pleroma.List.create(%{title: "foo", exclusive: true}, user)
	{:ok, _list} = Pleroma.List.follow(list, other_user1)

	{:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi"})
	{:ok, %{id: activity2_id}} = CommonAPI.post(other_user2, %{status: "hi too"})

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^activity2_id}] = response
	end
	end

	describe "public" do
	test "the public timeline", %{conn: conn} do
	user = insert(:user)

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

	remote = insert(:note_activity, local: false)

	assert conn
	\|> get("/api/v1/timelines/public?local=False")
	\|> json_response_and_validate_schema(:ok)
	\|> length == 3

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=True")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=True")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=True&only_media=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/public?local=1")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote.id in local_ids

	remote_id = remote.id

	assert [%{"id" => ^remote_id}] =
	conn
	\|> get("/api/v1/timelines/public?remote=true")
	\|> json_response_and_validate_schema(:ok)

	with_media_id = with_media.id

	assert [%{"id" => ^with_media_id}] =
	conn
	\|> get("/api/v1/timelines/public?only_media=true")
	\|> json_response_and_validate_schema(:ok)

	assert conn
	\|> get("/api/v1/timelines/public?remote=true&only_media=true")
	\|> json_response_and_validate_schema(:ok) == []

	# does not contain repeats
	{:ok, _} = CommonAPI.repeat(activity.id, user)

	assert [_, _] =
	conn
	\|> get("/api/v1/timelines/public?local=true")
	\|> json_response_and_validate_schema(:ok)
	end

	test "the public timeline includes only public statuses for an authenticated user" do
	%{user: user, conn: conn} = oauth_access(["read:statuses"])

	{:ok, _activity} = CommonAPI.post(user, %{status: "test"})
	{:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "private"})
	{:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "unlisted"})
	{:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "direct"})

	res_conn = get(conn, "/api/v1/timelines/public")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end

	test "doesn't return replies if follower is posting with blocked user" do
	%{conn: conn, user: blocker} = oauth_access(["read:statuses"])
	[blockee, friend] = insert_list(2, :user)
	{:ok, blocker, friend} = User.follow(blocker, friend)
	{:ok, _} = User.block(blocker, blockee)

	conn = assign(conn, :user, blocker)

	{:ok, %{id: activity_id} = activity} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, reply_from_blockee} =
	CommonAPI.post(blockee, %{status: "heya", in_reply_to_status_id: activity})

	{:ok, _reply_from_friend} =
	CommonAPI.post(friend, %{status: "status", in_reply_to_status_id: reply_from_blockee})

	# Still shows replies from yourself
	{:ok, %{id: reply_from_me}} =
	CommonAPI.post(blocker, %{status: "status", in_reply_to_status_id: reply_from_blockee})

	response =
	get(conn, "/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 2
	[%{"id" => ^reply_from_me}, %{"id" => ^activity_id}] = response
	end

	test "doesn't return posts from users who blocked you when :blockers_visible is disabled" do
	clear_config([:activitypub, :blockers_visible], false)

	%{conn: conn, user: blockee} = oauth_access(["read:statuses"])
	blocker = insert(:user)
	{:ok, _} = User.block(blocker, blockee)

	conn = assign(conn, :user, blockee)

	{:ok, _} = CommonAPI.post(blocker, %{status: "hey!"})

	response =
	get(conn, "/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 0
	end

	test "doesn't return replies if follow is posting with users from blocked domain" do
	%{conn: conn, user: blocker} = oauth_access(["read:statuses"])
	friend = insert(:user)
	blockee = insert(:user, ap_id: "https://example.com/users/blocked")
	{:ok, blocker, friend} = User.follow(blocker, friend)
	{:ok, blocker} = User.block_domain(blocker, "example.com")

	conn = assign(conn, :user, blocker)

	{:ok, %{id: activity_id} = activity} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, reply_from_blockee} =
	CommonAPI.post(blockee, %{status: "heya", in_reply_to_status_id: activity})

	{:ok, _reply_from_friend} =
	CommonAPI.post(friend, %{status: "status", in_reply_to_status_id: reply_from_blockee})

	res_conn = get(conn, "/api/v1/timelines/public")

	activities = json_response_and_validate_schema(res_conn, 200)
	[%{"id" => ^activity_id}] = activities
	end

	test "can be filtered by instance", %{conn: conn} do
	user = insert(:user, ap_id: "https://lain.com/users/lain")
	insert(:note_activity, local: false)
	insert(:note_activity, local: false)

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

	conn = get(conn, "/api/v1/timelines/public?instance=lain.com")

	assert length(json_response_and_validate_schema(conn, :ok)) == 1
	end

	test "muted emotions", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])

	conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/timelines/public?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "should return local-only posts for authenticated users" do
	user = insert(:user)
	%{user: _reader, conn: conn} = oauth_access(["read:statuses"])

	{:ok, %{id: id}} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	result =
	conn
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id}] = result
	end

	test "should not return local-only posts for users without read:statuses" do
	user = insert(:user)
	%{user: _reader, conn: conn} = oauth_access([])

	{:ok, _activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	result =
	conn
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [] = result
	end

	test "should not return local-only posts for anonymous users" do
	user = insert(:user)

	{:ok, _activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	result =
	build_conn()
	\|> get("/api/v1/timelines/public")
	\|> json_response_and_validate_schema(200)

	assert [] = result
	end
	end

	defp local_and_remote_activities do
	insert(:note_activity)
	insert(:note_activity, local: false)
	:ok
	end

	describe "public with restrict unauthenticated timeline for local and federated timelines" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :timelines, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	test "if user is unauthenticated", %{conn: conn} do
	res_conn = get(conn, "/api/v1/timelines/public?local=true")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}

	res_conn = get(conn, "/api/v1/timelines/public?local=false")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}
	end

	test "if user is authenticated" do
	%{conn: conn} = oauth_access(["read:statuses"])

	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "public with restrict unauthenticated timeline for local" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :timelines, :local], true)

	test "if user is unauthenticated", %{conn: conn} do
	res_conn = get(conn, "/api/v1/timelines/public?local=true")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end

	test "if user is authenticated", %{conn: _conn} do
	%{conn: conn} = oauth_access(["read:statuses"])

	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "public with restrict unauthenticated timeline for remote" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	test "if user is unauthenticated", %{conn: conn} do
	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "authorization required for timeline view"
	}
	end

	test "if user is authenticated", %{conn: _conn} do
	%{conn: conn} = oauth_access(["read:statuses"])

	res_conn = get(conn, "/api/v1/timelines/public?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/timelines/public?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "direct" do
	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two, user_one} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	status: "Hi @#{user_two.nickname}!",
	visibility: "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	status: "Hi @#{user_two.nickname}!",
	visibility: "private"
	})

	conn_user_two =
	conn
	\|> assign(:user, user_two)
	\|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))

	# Only direct should be visible here
	res_conn = get(conn_user_two, "/api/v1/timelines/direct")

	assert [status] = json_response_and_validate_schema(res_conn, :ok)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see their own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> assign(:token, insert(:oauth_token, user: user_one, scopes: ["read:statuses"]))
	\|> get("/api/v1/timelines/direct")

	[status] = json_response_and_validate_schema(res_conn, :ok)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn = get(conn_user_two, "/api/v1/timelines/home")

	[_s1, _s2] = json_response_and_validate_schema(res_conn, :ok)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	status: "Hi @#{user_two.nickname}!",
	visibility: "direct"
	})
	end)

	res_conn = get(conn_user_two, "/api/v1/timelines/direct")

	statuses = json_response_and_validate_schema(res_conn, :ok)
	assert length(statuses) == 20

	max_id = List.last(statuses)["id"]

	res_conn = get(conn_user_two, "/api/v1/timelines/direct?max_id=#{max_id}")

	assert [status] = json_response_and_validate_schema(res_conn, :ok)

	assert status["url"] != direct.data["id"]
	end

	test "doesn't include DMs from blocked users" do
	%{user: blocker, conn: conn} = oauth_access(["read:statuses"])
	blocked = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(blocker, blocked)

	{:ok, _blocked_direct} =
	CommonAPI.post(blocked, %{
	status: "Hi @#{blocker.nickname}!",
	visibility: "direct"
	})

	{:ok, direct} =
	CommonAPI.post(other_user, %{
	status: "Hi @#{blocker.nickname}!",
	visibility: "direct"
	})

	res_conn = get(conn, "/api/v1/timelines/direct")

	[status] = json_response_and_validate_schema(res_conn, :ok)
	assert status["id"] == direct.id
	end
	end

	describe "list" do
	setup do: oauth_access(["read:lists"])

	test "does not contain retoots", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(user, %{status: "Marisa is cute."})
	{:ok, activity_two} = CommonAPI.post(other_user, %{status: "Marisa is stupid."})
	{:ok, _} = CommonAPI.repeat(activity_one.id, other_user)

	- {:ok, list} = Pleroma.List.create("name", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn = get(conn, "/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)

	assert id == to_string(activity_two.id)
	end

	test "works with pagination", %{user: user, conn: conn} do
	other_user = insert(:user)
	- {:ok, list} = Pleroma.List.create("name", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	Enum.each(1..30, fn i ->
	CommonAPI.post(other_user, %{status: "post number #{i}"})
	end)

	res =
	get(conn, "/api/v1/timelines/list/#{list.id}?limit=1")
	\|> json_response_and_validate_schema(:ok)

	assert length(res) == 1

	[first] = res

	res =
	get(conn, "/api/v1/timelines/list/#{list.id}?max_id=#{first["id"]}&limit=30")
	\|> json_response_and_validate_schema(:ok)

	assert length(res) == 29
	end

	test "list timeline", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, _activity_one} = CommonAPI.post(user, %{status: "Marisa is cute."})
	{:ok, activity_two} = CommonAPI.post(other_user, %{status: "Marisa is cute."})
	- {:ok, list} = Pleroma.List.create("name", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn = get(conn, "/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{
	user: user,
	conn: conn
	} do
	other_user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(other_user, %{status: "Marisa is cute."})

	{:ok, _activity_two} =
	CommonAPI.post(other_user, %{
	status: "Marisa is cute.",
	visibility: "private"
	})

	- {:ok, list} = Pleroma.List.create("name", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn = get(conn, "/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, :ok)

	assert id == to_string(activity_one.id)
	end

	test "muted emotions", %{user: user, conn: conn} do
	user2 = insert(:user)
	user3 = insert(:user)
	{:ok, activity} = CommonAPI.post(user2, %{status: "."})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user3, "🎅")
	User.mute(user, user3)

	- {:ok, list} = Pleroma.List.create("name", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "name"}, user)
	{:ok, list} = Pleroma.List.follow(list, user2)

	result =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "filtering", %{user: user, conn: conn} do
	- {:ok, list} = Pleroma.List.create("name", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "name"}, user)

	local_user = insert(:user)
	{:ok, local_activity} = CommonAPI.post(local_user, %{status: "Marisa is stupid."})
	with_media = create_with_media_activity(local_user)
	{:ok, list} = Pleroma.List.follow(list, local_user)

	remote_user = insert(:user, local: false)
	remote_activity = create_remote_activity(remote_user)
	{:ok, list} = Pleroma.List.follow(list, remote_user)

	all_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in all_ids
	assert with_media.id in all_ids
	assert remote_activity.id in all_ids

	only_local_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?local=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	assert local_activity.id in only_local_ids
	assert with_media.id in only_local_ids
	refute remote_activity.id in only_local_ids

	only_local_media_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?local=true&only_media=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in only_local_media_ids
	assert with_media.id in only_local_media_ids
	refute remote_activity.id in only_local_media_ids

	remote_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?remote=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in remote_ids
	refute with_media.id in remote_ids
	assert remote_activity.id in remote_ids

	assert conn
	\|> get("/api/v1/timelines/list/#{list.id}?remote=true&only_media=true")
	\|> json_response_and_validate_schema(200) == []

	only_media_ids =
	conn
	\|> get("/api/v1/timelines/list/#{list.id}?only_media=true")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	refute local_activity.id in only_media_ids
	assert with_media.id in only_media_ids
	refute remote_activity.id in only_media_ids

	assert conn
	\|> get("/api/v1/timelines/list/#{list.id}?only_media=true&local=true&remote=true")
	\|> json_response_and_validate_schema(200) == []
	end
	end

	describe "hashtag" do
	setup do: oauth_access(["n/a"])

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	{:ok, activity} = CommonAPI.post(following, %{status: "test #2hu"})
	with_media = create_with_media_activity(following)

	remote = insert(:user, local: false)
	remote_activity = create_remote_activity(remote)

	all_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in all_ids
	assert with_media.id in all_ids
	assert remote_activity.id in all_ids

	# works for different capitalization too
	all_ids =
	conn
	\|> get("/api/v1/timelines/tag/2HU")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in all_ids
	assert with_media.id in all_ids
	assert remote_activity.id in all_ids

	local_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?local=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	assert activity.id in local_ids
	assert with_media.id in local_ids
	refute remote_activity.id in local_ids

	remote_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?remote=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in remote_ids
	refute with_media.id in remote_ids
	assert remote_activity.id in remote_ids

	media_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in media_ids
	assert with_media.id in media_ids
	refute remote_activity.id in media_ids

	media_local_ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true&local=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in media_local_ids
	assert with_media.id in media_local_ids
	refute remote_activity.id in media_local_ids

	ids =
	conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true&local=true&remote=true")
	\|> json_response_and_validate_schema(:ok)
	\|> Enum.map(& &1["id"])

	refute activity.id in ids
	refute with_media.id in ids
	refute remote_activity.id in ids

	assert conn
	\|> get("/api/v1/timelines/tag/2hu?only_media=true&remote=true")
	\|> json_response_and_validate_schema(:ok) == []
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{status: "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{status: "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{status: "#test #none"})

	any_test = get(conn, "/api/v1/timelines/tag/test?any[]=test1")

	[status_none, status_test1, status_test] = json_response_and_validate_schema(any_test, :ok)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test = get(conn, "/api/v1/timelines/tag/test?all[]=test1&none[]=none")

	assert [status_test1] == json_response_and_validate_schema(restricted_test, :ok)

	all_test = get(conn, "/api/v1/timelines/tag/test?all[]=none")

	assert [status_none] == json_response_and_validate_schema(all_test, :ok)
	end

	test "muted emotions", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])

	conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/timelines/tag/2hu")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/timelines/tag/2hu?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end
	end

	describe "hashtag timeline handling of restrict_unauthenticated setting" do
	setup do
	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "test #tag1"})
	{:ok, _activity2} = CommonAPI.post(user, %{status: "test #tag1"})

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

	base_uri = "/api/v1/timelines/tag/tag1"
	error_response = %{"error" => "authorization required for timeline view"}

	%{base_uri: base_uri, error_response: error_response}
	end

	defp ensure_authenticated_access(base_uri) do
	%{conn: auth_conn} = oauth_access(["read:statuses"])

	res_conn = get(auth_conn, "#{base_uri}?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(auth_conn, "#{base_uri}?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end

	test "with default settings on private instances, returns 403 for unauthenticated users", %{
	conn: conn,
	base_uri: base_uri,
	error_response: error_response
	} do
	clear_config([:instance, :public], false)
	clear_config([:restrict_unauthenticated, :timelines])

	for local <- [true, false] do
	res_conn = get(conn, "#{base_uri}?local=#{local}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response
	end

	ensure_authenticated_access(base_uri)
	end

	test "with `%{local: true, federated: true}`, returns 403 for unauthenticated users", %{
	conn: conn,
	base_uri: base_uri,
	error_response: error_response
	} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	for local <- [true, false] do
	res_conn = get(conn, "#{base_uri}?local=#{local}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response
	end

	ensure_authenticated_access(base_uri)
	end

	test "with `%{local: false, federated: true}`, forbids unauthenticated access to federated timeline",
	%{conn: conn, base_uri: base_uri, error_response: error_response} do
	clear_config([:restrict_unauthenticated, :timelines, :local], false)
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	res_conn = get(conn, "#{base_uri}?local=true")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "#{base_uri}?local=false")
	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response

	ensure_authenticated_access(base_uri)
	end

	test "with `%{local: true, federated: false}`, forbids unauthenticated access to public timeline" <>
	"(but not to local public activities which are delivered as part of federated timeline)",
	%{conn: conn, base_uri: base_uri, error_response: error_response} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)
	clear_config([:restrict_unauthenticated, :timelines, :federated], false)

	res_conn = get(conn, "#{base_uri}?local=true")
	assert json_response_and_validate_schema(res_conn, :unauthorized) == error_response

	# Note: local activities get delivered as part of federated timeline
	res_conn = get(conn, "#{base_uri}?local=false")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 2

	ensure_authenticated_access(base_uri)
	end
	end

	defp create_remote_activity(user) do
	obj =
	insert(:note, %{
	data: %{
	"to" => [
	"https://www.w3.org/ns/activitystreams#Public",
	User.ap_followers(user)
	]
	},
	user: user
	})

	insert(:note_activity, %{
	note: obj,
	recipients: [
	"https://www.w3.org/ns/activitystreams#Public",
	User.ap_followers(user)
	],
	user: user,
	local: false
	})
	end

	defp create_with_media_activity(user) do
	obj = insert(:attachment_note, user: user)

	insert(:note_activity, %{
	note: obj,
	recipients: ["https://www.w3.org/ns/activitystreams#Public", User.ap_followers(user)],
	user: user
	})
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/list_view_test.exs b/test/pleroma/web/mastodon_api/views/list_view_test.exs
	index bbf87bab2..ae0593b6b 100644
	--- a/test/pleroma/web/mastodon_api/views/list_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/list_view_test.exs
	@@ -1,32 +1,36 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.ListViewTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.MastodonAPI.ListView

	test "show" do
	user = insert(:user)
	title = "mortal enemies"
	- {:ok, list} = Pleroma.List.create(title, user)
	+ {:ok, list} = Pleroma.List.create(%{title: title}, user)

	expected = %{
	id: to_string(list.id),
	- title: title
	+ title: title,
	+ exclusive: false
	}

	assert expected == ListView.render("show.json", %{list: list})
	end

	test "index" do
	user = insert(:user)

	- {:ok, list} = Pleroma.List.create("my list", user)
	- {:ok, list2} = Pleroma.List.create("cofe", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "my list", exclusive: false}, user)
	+ {:ok, list2} = Pleroma.List.create(%{title: "cofe", exclusive: true}, user)

	- assert [%{id: _, title: "my list"}, %{id: _, title: "cofe"}] =
	+ assert [
	+ %{id: _, title: "my list", exclusive: false},
	+ %{id: _, title: "cofe", exclusive: true}
	+ ] =
	ListView.render("index.json", lists: [list, list2])
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/status_view_test.exs b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	index 73cab817b..76123cd0f 100644
	--- a/test/pleroma/web/mastodon_api/views/status_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	@@ -1,1012 +1,1012 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Conversation.Participation
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.RichMedia.Card

	require Bitwise

	import Mox
	import OpenApiSpex.TestAssertions
	import Pleroma.Factory
	import Tesla.Mock

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

	test "has an emoji reaction list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, ":dinosaur:")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: false, url: nil, account_ids: [other_user.id, user.id]},
	%{
	count: 2,
	me: false,
	name: "dinosaur",
	url: "http://localhost:4001/emoji/dino%20walking.gif",
	account_ids: [other_user.id, user.id]
	},
	%{name: "🍵", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: true, url: nil, account_ids: [other_user.id, user.id]},
	%{
	count: 2,
	me: true,
	name: "dinosaur",
	url: "http://localhost:4001/emoji/dino%20walking.gif",
	account_ids: [other_user.id, user.id]
	},
	%{name: "🍵", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]
	end

	test "works with legacy-formatted reactions" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "😿", count: 1, me: false, url: nil, account_ids: [other_user.id]}
	]
	end

	test "works correctly with badly formatted emojis" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "yo"})

	activity
	\|> Object.normalize(fetch: false)
	\|> Object.update_data(%{"reactions" => %{"☕" => [user.ap_id], "x" => 1}})

	activity = Activity.get_by_id(activity.id)
	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true, url: nil, account_ids: [user.id]}
	]
	end

	test "doesn't show reactions from muted and blocked users" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, _} = User.mute(user, other_user)
	{:ok, _} = User.block(other_user, third_user)

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false, url: nil, account_ids: [other_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "☕")

	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{
	name: "☕",
	count: 2,
	me: false,
	url: nil,
	account_ids: [third_user.id, other_user.id]
	}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: other_user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true, url: nil, account_ids: [other_user.id]}
	]
	end

	test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	with_direct_conversation_id: true,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id

	status = StatusView.render("show.json", activity: activity, for: user)
	assert status[:pleroma][:direct_conversation_id] == nil
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns the direct conversation id when given the `direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	direct_conversation_id: participation.id,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	Repo.delete(user)
	User.invalidate_cache(user)

	finger_url =
	"https://localhost/.well-known/webfinger?resource=acct:#{user.nickname}@localhost"

	Tesla.Mock.mock_global(fn
	%{method: :get, url: "http://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{method: :get, url: "https://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{
	method: :get,
	url: ^finger_url
	} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	%{account: ms_user} = StatusView.render("show.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	User.invalidate_cache(user)

	result = StatusView.render("show.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note with null content" do
	note = insert(:note_activity)
	note_object = Object.normalize(note, fetch: false)

	data =
	note_object.data
	\|> Map.put("content", nil)

	Object.change(note_object, %{data: data})
	\|> Object.update_and_set_cache()

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("show.json", %{activity: note})

	assert status.content == ""
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note activity" do
	note = insert(:note_activity)
	object_data = Object.normalize(note, fetch: false).data
	user = User.get_cached_by_ap_id(note.data["actor"])

	convo_id = :erlang.crc32(object_data["context"]) \|> Bitwise.band(Bitwise.bnot(0x8000_0000))

	status = StatusView.render("show.json", %{activity: note})

	created_at =
	(object_data["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: object_data["id"],
	url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
	account: AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HTML.filter_tags(object_data["content"]),
	text: nil,
	created_at: created_at,
	edited_at: nil,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	poll: nil,
	spoiler_text: HTML.filter_tags(object_data["summary"]),
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{hd(object_data["tag"])}",
	url: "http://localhost:4001/tag/#{hd(object_data["tag"])}"
	}
	],
	application: nil,
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	],
	pleroma: %{
	local: true,
	conversation_id: convo_id,
	context: object_data["context"],
	in_reply_to_account_acct: nil,
	quote: nil,
	quote_id: nil,
	quote_url: nil,
	quote_visible: false,
	content: %{"text/plain" => HTML.strip_tags(object_data["content"])},
	spoiler_text: %{"text/plain" => HTML.strip_tags(object_data["summary"])},
	expires_at: nil,
	direct_conversation_id: nil,
	thread_muted: false,
	emoji_reactions: [],
	parent_visible: false,
	pinned_at: nil,
	quotes_count: 0,
	bookmark_folder: nil,
	list_id: nil
	},
	quotes_count: 0
	}

	assert status == expected
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user)

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

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])

	opts = %{activity: activity}
	status = StatusView.render("show.json", opts)
	assert status.muted == false
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
	assert status.muted == false

	for_opts = %{activity: activity, for: user}
	status = StatusView.render("show.json", for_opts)
	assert status.muted == true

	status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
	assert status.muted == true
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is thread muted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == false

	{:ok, activity} = CommonAPI.add_mute(activity, user)

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == true
	end

	test "tells if the status is bookmarked" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
	status = StatusView.render("show.json", %{activity: activity})

	assert status.bookmarked == false

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.bookmarked == false

	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)

	activity = Activity.get_by_id_with_object(activity.id)

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.bookmarked == true
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})

	status = StatusView.render("show.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

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

	{:ok, quote_post} = CommonAPI.post(user, %{status: "he", quoted_status_id: post.id})

	{:ok, quoted_quote_post} =
	CommonAPI.post(user, %{status: "yo", quoted_status_id: quote_post.id})

	status = StatusView.render("show.json", %{activity: quoted_quote_post})

	assert status.pleroma.quote.id == to_string(quote_post.id)
	assert status.pleroma.quote_id == to_string(quote_post.id)
	assert status.pleroma.quote_url == Object.normalize(quote_post).data["id"]
	assert status.pleroma.quote_visible

	# Quotes don't go more than one level deep
	refute status.pleroma.quote.pleroma.quote
	assert status.pleroma.quote.pleroma.quote_id == to_string(post.id)
	assert status.pleroma.quote.pleroma.quote_url == Object.normalize(post).data["id"]
	assert status.pleroma.quote.pleroma.quote_visible

	# In an index
	[status] = StatusView.render("index.json", %{activities: [quoted_quote_post], as: :activity})

	assert status.pleroma.quote.id == to_string(quote_post.id)
	end

	test "quoted private post" do
	user = insert(:user)

	# Insert a private post
	private = insert(:followers_only_note_activity, user: user)
	private_object = Object.normalize(private)

	# Create a public post quoting the private post
	quote_private =
	insert(:note_activity,
	note: insert(:note, data: %{"quoteUrl" => private_object.data["id"]})
	)

	status = StatusView.render("show.json", %{activity: quote_private})

	# The quote isn't rendered
	refute status.pleroma.quote
	assert status.pleroma.quote_url == private_object.data["id"]
	refute status.pleroma.quote_visible

	# After following the user, the quote is rendered
	follower = insert(:user)
	CommonAPI.follow(user, follower)

	status = StatusView.render("show.json", %{activity: quote_private, for: follower})
	assert status.pleroma.quote.id == to_string(private.id)
	assert status.pleroma.quote_visible
	end

	test "quoted direct message" do
	# Insert a direct message
	direct = insert(:direct_note_activity)
	direct_object = Object.normalize(direct)

	# Create a public post quoting the direct message
	quote_direct =
	insert(:note_activity, note: insert(:note, data: %{"quoteUrl" => direct_object.data["id"]}))

	status = StatusView.render("show.json", %{activity: quote_direct})

	# The quote isn't rendered
	refute status.pleroma.quote
	assert status.pleroma.quote_url == direct_object.data["id"]
	refute status.pleroma.quote_visible
	end

	test "repost of quote post" do
	post = insert(:note_activity)
	user = insert(:user)

	{:ok, quote_post} = CommonAPI.post(user, %{status: "he", quoted_status_id: post.id})
	{:ok, repost} = CommonAPI.repeat(quote_post.id, user)

	[status] = StatusView.render("index.json", %{activities: [repost], as: :activity})

	assert status.reblog.pleroma.quote.id == to_string(post.id)
	end

	test "contains mentions" do
	user = insert(:user)
	mentioned = insert(:user)

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

	status = StatusView.render("show.json", %{activity: activity})

	assert status.mentions ==
	Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "create mentions from the 'to' field" do
	%User{ap_id: recipient_ap_id} = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"to" => [recipient_ap_id],
	"cc" => cc
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient_ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient_ap_id
	end

	test "create mentions from the 'tag' field" do
	recipient = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"cc" => cc,
	"tag" => [
	%{
	"href" => recipient.ap_id,
	"name" => recipient.nickname,
	"type" => "Mention"
	},
	%{
	"href" => "https://example.com/search?tag=test",
	"name" => "#test",
	"type" => "Hashtag"
	}
	]
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient.ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient.ap_id
	end

	describe "attachments" do
	test "Complete Mastodon style" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl",
	"width" => 200,
	"height" => 100
	}
	],
	"blurhash" => "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn",
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil,
	pleroma: %{mime_type: "image/png"},
	meta: %{original: %{width: 200, height: 100, aspect: 2}},
	blurhash: "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

	assert expected == StatusView.render("attachment.json", %{attachment: object})
	assert_schema(expected, "Attachment", api_spec)

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	result = StatusView.render("attachment.json", %{attachment: object})

	assert %{id: "2"} = result
	assert_schema(result, "Attachment", api_spec)
	end

	test "Honkerific" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"name" => "fool.jpeg",
	"summary" => "they have played us for absolute fools."
	}

	expected = %{
	blurhash: nil,
	description: "they have played us for absolute fools.",
	id: "1638338801",
	pleroma: %{mime_type: "image/png", name: "fool.jpeg"},
	preview_url: "someurl",
	remote_url: "someurl",
	text_url: "someurl",
	type: "image",
	url: "someurl"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

	assert expected == StatusView.render("attachment.json", %{attachment: object})
	assert_schema(expected, "Attachment", api_spec)
	end
	end

	test "put the url advertised in the Activity in to the url attribute" do
	id = "https://wedistribute.org/wp-json/pterotype/v1/object/85810"
	[activity] = Activity.search(nil, id)

	status = StatusView.render("show.json", %{activity: activity})

	assert status.uri == id
	assert status.url == "https://wedistribute.org/2019/07/mastodon-drops-ostatus/"
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

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

	represented = StatusView.render("show.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "funkwhale audio" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	test "a Mobilizon event" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)

	assert represented[:url] ==
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"

	assert represented[:content] ==
	"<p><a href=\"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39\">Mobilizon Launching Party</a></p><p>Mobilizon is now federated! 🎉</p><p></p><p>You can view this event from other instances if they are subscribed to mobilizon.org, and soon directly from Mastodon and Pleroma. It is possible that you may see some comments from other instances, including Mastodon ones, just below.</p><p></p><p>With a Mobilizon account on an instance, you may <strong>participate</strong> at events from other instances and <strong>add comments</strong> on events.</p><p></p><p>Of course, it's still <u>a work in progress</u>: if reports made from an instance on events and comments can be federated, you can't block people right now, and moderators actions are rather limited, but this <strong>will definitely get fixed over time</strong> until first stable version next year.</p><p></p><p>Anyway, if you want to come up with some feedback, head over to our forum or - if you feel you have technical skills and are familiar with it - on our Gitlab repository.</p><p></p><p>Also, to people that want to set Mobilizon themselves even though we really don't advise to do that for now, we have a little documentation but it's quite the early days and you'll probably need some help. No worries, you can chat with us on our Forum or though our Matrix channel.</p><p></p><p>Check our website for more informations and follow us on Twitter or Mastodon.</p>"
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "http://localhost:4001/tag/fediverse"},
	%{name: "mastodon", url: "http://localhost:4001/tag/mastodon"},
	%{name: "nextcloud", url: "http://localhost:4001/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "https://example.com"

	{:ok, card} =
	Card.create(page_url, %{image: page_url <> "/example.jpg", title: "Example website"})

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without an image renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without descriptions returns the fields with empty strings" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(
	%{description: "", image_description: ""},
	StatusView.render("card.json", card)
	)
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website",
	"image" => page_url <> "/example.jpg",
	"description" => "Example description"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card has all media proxied" do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled])

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

	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website",
	"image" => page_url <> "/example.jpg",
	"audio" => page_url <> "/example.ogg",
	"video" => page_url <> "/example.mp4",
	"description" => "Example description"
	}

	{:ok, card} = Card.create(page_url, fields)

	%{
	provider_name: "example.com",
	image: image,
	pleroma: %{opengraph: og}
	} = StatusView.render("card.json", card)

	assert String.match?(image, ~r/\/proxy\//)
	assert String.match?(og["image"], ~r/\/proxy\//)
	assert String.match?(og["audio"], ~r/\/proxy\//)
	assert String.match?(og["video"], ~r/\/proxy\//)
	end
	end

	test "does not embed a relationship in the account" do
	user = insert(:user)
	other_user = insert(:user)

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

	result = StatusView.render("show.json", %{activity: activity, for: other_user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "does not embed a relationship in the account in reposts" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "˙˙ɐʎns"
	})

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

	result = StatusView.render("show.json", %{activity: activity, for: user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert result[:reblog][:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "visibility/list" do
	user = insert(:user)

	- {:ok, list} = Pleroma.List.create("foo", user)
	+ {:ok, list} = Pleroma.List.create(%{title: "foo"}, user)

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

	status = StatusView.render("show.json", activity: activity)

	assert status.visibility == "list"
	assert status.pleroma.list_id == nil

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status.pleroma.list_id == list.id
	end

	test "has a field for parent visibility" do
	user = insert(:user)
	poster = insert(:user)

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

	{:ok, visible} =
	CommonAPI.post(poster, %{status: "hey", visibility: "private", in_reply_to_id: invisible.id})

	status = StatusView.render("show.json", activity: visible, for: user)
	refute status.pleroma.parent_visible

	status = StatusView.render("show.json", activity: visible, for: poster)
	assert status.pleroma.parent_visible
	end

	test "it shows edited_at" do
	poster = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	status = StatusView.render("show.json", activity: post)
	refute status.edited_at

	{:ok, _} = CommonAPI.update(post, poster, %{status: "mew mew"})
	edited = Pleroma.Activity.normalize(post)

	status = StatusView.render("show.json", activity: edited)
	assert status.edited_at
	end

	test "it shows post language" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "Szczęść Boże", language: "pl"})

	status = StatusView.render("show.json", activity: post)

	assert status.language == "pl"
	end

	test "doesn't show post language if it's 'und'" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "sdifjogijodfg", language: "und"})

	status = StatusView.render("show.json", activity: post)

	assert status.language == nil
	end

	test "with a source object" do
	note =
	insert(:note,
	data: %{"source" => %{"content" => "object source", "mediaType" => "text/markdown"}}
	)

	activity = insert(:note_activity, note: note)

	status = StatusView.render("show.json", activity: activity, with_source: true)
	assert status.text == "object source"
	end

	describe "source.json" do
	test "with a source object, renders both source and content type" do
	note =
	insert(:note,
	data: %{"source" => %{"content" => "object source", "mediaType" => "text/markdown"}}
	)

	activity = insert(:note_activity, note: note)

	status = StatusView.render("source.json", activity: activity)
	assert status.text == "object source"
	assert status.content_type == "text/markdown"
	end

	test "with a source string, renders source and put text/plain as the content type" do
	note = insert(:note, data: %{"source" => "string source"})
	activity = insert(:note_activity, note: note)

	status = StatusView.render("source.json", activity: activity)
	assert status.text == "string source"
	assert status.content_type == "text/plain"
	end
	end
	end
	diff --git a/test/pleroma/web/streamer_test.exs b/test/pleroma/web/streamer_test.exs
	index f5008f6b9..b26bd1847 100644
	--- a/test/pleroma/web/streamer_test.exs
	+++ b/test/pleroma/web/streamer_test.exs
	@@ -1,1117 +1,1117 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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])
	Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)

	:ok
	end

	describe "get_topic/_ (unauthenticated)" do
	test "allows no stream" do
	assert {:ok, nil} = Streamer.get_topic(nil, nil, nil)
	end

	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 "rejects local public streams if restricted_unauthenticated is on" do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)

	assert {:error, :unauthorized} = Streamer.get_topic("public:local", nil, nil)
	assert {:error, :unauthorized} = Streamer.get_topic("public:local:media", nil, nil)
	end

	test "rejects remote public streams if restricted_unauthenticated is on" do
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	assert {:error, :unauthorized} = Streamer.get_topic("public", nil, nil)
	assert {:error, :unauthorized} = Streamer.get_topic("public:media", nil, nil)

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
	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 local public streams if restricted_unauthenticated is on", %{
	user: user,
	token: oauth_token
	} do
	clear_config([:restrict_unauthenticated, :timelines, :local], true)

	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)

	assert {:ok, "public:local:media"} =
	Streamer.get_topic("public:local:media", user, oauth_token)

	for token <- [read_notifications_token, badly_scoped_token] do
	assert {:error, :unauthorized} = Streamer.get_topic("public:local", user, token)

	assert {:error, :unauthorized} = Streamer.get_topic("public:local:media", user, token)
	end
	end

	test "allows remote public streams if restricted_unauthenticated is on", %{
	user: user,
	token: oauth_token
	} do
	clear_config([:restrict_unauthenticated, :timelines, :federated], true)

	%{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
	%{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)

	assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
	assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)

	assert {:ok, "public:remote:lain.com"} =
	Streamer.get_topic("public:remote", user, oauth_token, %{"instance" => "lain.com"})

	assert {:ok, "public:remote:media:lain.com"} =
	Streamer.get_topic("public:remote:media", user, oauth_token, %{
	"instance" => "lain.com"
	})

	for token <- [read_notifications_token, badly_scoped_token] do
	assert {:error, :unauthorized} = Streamer.get_topic("public", user, token)
	assert {:error, :unauthorized} = Streamer.get_topic("public:media", user, token)

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote", user, token, %{
	"instance" => "lain.com"
	})

	assert {:error, :unauthorized} =
	Streamer.get_topic("public:remote:media", user, token, %{
	"instance" => "lain.com"
	})
	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)
	+ {:ok, list} = List.create(%{title: "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)
	+ {:ok, list} = List.create(%{title: "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")
	\|> 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, fetch: 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},
	"user:pleroma_chat:#{user.id}"
	)

	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, fetch: 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},
	"user:#{user.id}"
	)

	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(activity.id, blocked)

	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(activity, user)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	{:ok, favorite_activity} = CommonAPI.favorite(activity.id, user2)

	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(activity.id, user2)

	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(activity.id, user2)

	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
	user2 = insert(:user)

	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
	{:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user, user2)

	assert_receive {:render_with_user, _, "notification.json", notif, _}
	assert notif.activity.id == follow_activity.id
	refute Streamer.filtered_by_user?(user, notif)
	end

	test "it sends follow relationships updates to the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	user_id = user.id
	other_user = insert(:user)
	other_user_id = other_user.id

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, _follower, _followed, _follow_activity} = CommonAPI.follow(other_user, user)

	assert_receive {:text, event}

	assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
	Jason.decode!(event)

	assert %{
	"follower" => %{
	"follower_count" => 0,
	"following_count" => 0,
	"id" => ^user_id
	},
	"following" => %{
	"follower_count" => 0,
	"following_count" => 0,
	"id" => ^other_user_id
	},
	"state" => "follow_pending"
	} = Jason.decode!(payload)

	assert_receive {:text, event}

	assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
	Jason.decode!(event)

	assert %{
	"follower" => %{
	"follower_count" => 0,
	"following_count" => 1,
	"id" => ^user_id
	},
	"following" => %{
	"follower_count" => 1,
	"following_count" => 0,
	"id" => ^other_user_id
	},
	"state" => "follow_accept"
	} = Jason.decode!(payload)
	end

	test "it streams edits in the 'user' stream", %{user: user, token: oauth_token} do
	sender = insert(:user)
	{:ok, _, _, _} = CommonAPI.follow(sender, user)

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

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})
	create = Pleroma.Activity.get_create_by_object_ap_id_with_object(activity.object.data["id"])

	assert_receive {:render_with_user, _, "status_update.json", ^create, _}
	refute Streamer.filtered_by_user?(user, edited)
	end

	test "it streams own edits in the 'user' stream", %{user: user, token: oauth_token} do
	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, edited} = CommonAPI.update(activity, user, %{status: "mew mew"})
	create = Pleroma.Activity.get_create_by_object_ap_id_with_object(activity.object.data["id"])

	assert_receive {:render_with_user, _, "status_update.json", ^create, _}
	refute Streamer.filtered_by_user?(user, edited)
	end

	test "it streams posts containing followed hashtags on the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	hashtag = insert(:hashtag, %{name: "tenshi"})
	other_user = insert(:user)
	{:ok, user} = User.follow_hashtag(user, hashtag)

	Streamer.get_topic_and_add_socket("user", user, oauth_token)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey #tenshi"})

	assert_receive {:render_with_user, _, "update.json", ^activity, _}
	end

	test "should not stream private posts containing followed hashtags on the 'user' stream", %{
	user: user,
	token: oauth_token
	} do
	hashtag = insert(:hashtag, %{name: "tenshi"})
	other_user = insert(:user)
	{:ok, user} = User.follow_hashtag(user, hashtag)

	Streamer.get_topic_and_add_socket("user", user, oauth_token)

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

	refute_receive {:render_with_user, _, "update.json", ^activity, _}
	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

	test "it streams edits in the 'public' stream" do
	sender = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)
	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})
	assert_receive {:text, _}

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])

	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)
	end

	test "it streams multiple edits in the 'public' stream correctly" do
	sender = insert(:user)

	Streamer.get_topic_and_add_socket("public", nil, nil)
	{:ok, activity} = CommonAPI.post(sender, %{status: "hey"})
	assert_receive {:text, _}

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])

	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)

	{:ok, edited} = CommonAPI.update(activity, sender, %{status: "mew mew 2"})

	edited = Pleroma.Activity.normalize(edited)

	%{id: activity_id} = Pleroma.Activity.get_create_by_object_ap_id(edited.object.data["id"])
	assert_receive {:text, event}
	assert %{"event" => "status.update", "payload" => payload} = Jason.decode!(event)
	assert %{"id" => ^activity_id, "content" => "mew mew 2"} = Jason.decode!(payload)
	refute Streamer.filtered_by_user?(sender, edited)
	end
	end

	describe "thread_containment/2" do
	test "it filters to user if recipients invalid and thread containment is enabled" do
	clear_config([: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
	clear_config([: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
	clear_config([: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_b} = User.follow(user_a, user_b)

	- {:ok, list} = List.create("Test", user_a)
	+ {:ok, list} = List.create(%{title: "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.create(%{title: "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_b} = User.follow(user_a, user_b)

	- {:ok, list} = List.create("Test", user_a)
	+ {:ok, list} = List.create(%{title: "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(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{: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(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{: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 sends non-reblog notification for reblog-muted actors", %{
	user: user1,
	token: user1_token
	} do
	user2 = insert(:user)
	CommonAPI.follow(user2, user1)
	CommonAPI.hide_reblogs(user2, user1)

	{: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(create_activity.id, user2)

	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(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
	{:ok, _} = CommonAPI.add_mute(activity, user2)

	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

	@tag :erratic
	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

	describe "stop streaming if token got revoked" do
	setup do
	child_proc = fn start, finalize ->
	fn ->
	start.()

	receive do
	{StreamerTest, :ready} ->
	assert_receive {:render_with_user, _, "update.json", _, _}

	receive do
	{StreamerTest, :revoked} -> finalize.()
	end
	end
	end
	end

	starter = fn user, token ->
	fn -> Streamer.get_topic_and_add_socket("user", user, token) end
	end

	hit = fn -> assert_receive :close end
	miss = fn -> refute_receive :close end

	send_all = fn tasks, thing -> Enum.each(tasks, &send(&1.pid, thing)) end

	%{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	miss: miss,
	send_all: send_all
	}
	end

	test "do not revoke other tokens", %{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	miss: miss,
	send_all: send_all
	} do
	%{user: user, token: token} = oauth_access(["read"])
	%{token: token2} = oauth_access(["read"], user: user)
	%{user: user2, token: user2_token} = oauth_access(["read"])

	post_user = insert(:user)
	CommonAPI.follow(post_user, user)
	CommonAPI.follow(post_user, user2)

	tasks = [
	Task.async(child_proc.(starter.(user, token), hit)),
	Task.async(child_proc.(starter.(user, token2), miss)),
	Task.async(child_proc.(starter.(user2, user2_token), miss))
	]

	{:ok, _} =
	CommonAPI.post(post_user, %{
	status: "hi"
	})

	send_all.(tasks, {StreamerTest, :ready})

	Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)

	send_all.(tasks, {StreamerTest, :revoked})

	Enum.each(tasks, &Task.await/1)
	end

	test "revoke all streams for this token", %{
	child_proc: child_proc,
	starter: starter,
	hit: hit,
	send_all: send_all
	} do
	%{user: user, token: token} = oauth_access(["read"])

	post_user = insert(:user)
	CommonAPI.follow(post_user, user)

	tasks = [
	Task.async(child_proc.(starter.(user, token), hit)),
	Task.async(child_proc.(starter.(user, token), hit))
	]

	{:ok, _} =
	CommonAPI.post(post_user, %{
	status: "hi"
	})

	send_all.(tasks, {StreamerTest, :ready})

	Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)

	send_all.(tasks, {StreamerTest, :revoked})

	Enum.each(tasks, &Task.await/1)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jul 19, 8:02 AM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1695223
Default Alt Text: (463 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions