No OneTemporary
Actions

Authored By

Unknown

Size

162 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/rich_media_tests.skip b/changelog.d/rich_media_tests.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/lib/pleroma/caching.ex b/lib/pleroma/caching.ex
	index eb0588708..796a465af 100644
	--- a/lib/pleroma/caching.ex
	+++ b/lib/pleroma/caching.ex
	@@ -1,19 +1,22 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Caching do
	@callback get!(Cachex.cache(), any()) :: any()
	@callback get(Cachex.cache(), any()) :: {atom(), any()}
	@callback put(Cachex.cache(), any(), any(), Keyword.t()) :: {Cachex.status(), boolean()}
	@callback put(Cachex.cache(), any(), any()) :: {Cachex.status(), boolean()}
	@callback fetch!(Cachex.cache(), any(), function() \| nil) :: any()
	+ @callback fetch(Cachex.cache(), any(), function() \| nil) ::
	+ {atom(), any()} \| {atom(), any(), any()}
	# @callback del(Cachex.cache(), any(), Keyword.t()) :: {Cachex.status(), boolean()}
	@callback del(Cachex.cache(), any()) :: {Cachex.status(), boolean()}
	@callback stream!(Cachex.cache(), any()) :: Enumerable.t()
	@callback expire_at(Cachex.cache(), binary(), number()) :: {Cachex.status(), boolean()}
	+ @callback expire(Cachex.cache(), binary(), number()) :: {Cachex.status(), boolean()}
	@callback exists?(Cachex.cache(), any()) :: {Cachex.status(), boolean()}
	@callback execute!(Cachex.cache(), function()) :: any()
	@callback get_and_update(Cachex.cache(), any(), function()) ::
	{:commit \| :ignore, any()}
	end
	diff --git a/lib/pleroma/web/rich_media/helpers.ex b/lib/pleroma/web/rich_media/helpers.ex
	index 1501776d9..a711dc436 100644
	--- a/lib/pleroma/web/rich_media/helpers.ex
	+++ b/lib/pleroma/web/rich_media/helpers.ex
	@@ -1,152 +1,109 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Helpers do
	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Web.RichMedia.Parser

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	@config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)

	@options [
	pool: :media,
	max_body: 2_000_000,
	recv_timeout: 2_000
	]

	- @spec validate_page_url(URI.t() \| binary()) :: :ok \| :error
	- defp validate_page_url(page_url) when is_binary(page_url) do
	- validate_tld = @config_impl.get([Pleroma.Formatter, :validate_tld])
	-
	- page_url
	- \|> Linkify.Parser.url?(validate_tld: validate_tld)
	- \|> parse_uri(page_url)
	- end
	-
	- defp validate_page_url(%URI{host: host, scheme: "https"}) do
	- cond do
	- Linkify.Parser.ip?(host) ->
	- :error
	-
	- host in @config_impl.get([:rich_media, :ignore_hosts], []) ->
	- :error
	-
	- get_tld(host) in @config_impl.get([:rich_media, :ignore_tld], []) ->
	- :error
	-
	- true ->
	- :ok
	- end
	- end
	-
	- defp validate_page_url(_), do: :error
	-
	- defp parse_uri(true, url) do
	- url
	- \|> URI.parse()
	- \|> validate_page_url
	- end
	-
	- defp parse_uri(_, _), do: :error
	-
	- defp get_tld(host) do
	- host
	- \|> String.split(".")
	- \|> Enum.reverse()
	- \|> hd
	- end
	-
	def fetch_data_for_object(object) do
	with true <- @config_impl.get([:rich_media, :enabled]),
	{:ok, page_url} <-
	HTML.extract_first_external_url_from_object(object),
	- :ok <- validate_page_url(page_url),
	{:ok, rich_media} <- Parser.parse(page_url) do
	%{page_url: page_url, rich_media: rich_media}
	else
	_ -> %{}
	end
	end

	def fetch_data_for_activity(%Activity{data: %{"type" => "Create"}} = activity) do
	with true <- @config_impl.get([:rich_media, :enabled]),
	%Object{} = object <- Object.normalize(activity, fetch: false) do
	if object.data["fake"] do
	fetch_data_for_object(object)
	else
	key = "URL\|#{activity.id}"

	@cachex.fetch!(:scrubber_cache, key, fn _ ->
	result = fetch_data_for_object(object)

	cond do
	match?(%{page_url: _, rich_media: _}, result) ->
	Activity.HTML.add_cache_key_for(activity.id, key)
	{:commit, result}

	true ->
	{:ignore, %{}}
	end
	end)
	end
	else
	_ -> %{}
	end
	end

	def fetch_data_for_activity(_), do: %{}

	def rich_media_get(url) do
	headers = [{"user-agent", Pleroma.Application.user_agent() <> "; Bot"}]

	head_check =
	case Pleroma.HTTP.head(url, headers, @options) do
	# If the HEAD request didn't reach the server for whatever reason,
	# we assume the GET that comes right after won't either
	{:error, _} = e ->
	e

	{:ok, %Tesla.Env{status: 200, headers: headers}} ->
	with :ok <- check_content_type(headers),
	:ok <- check_content_length(headers),
	do: :ok

	_ ->
	:ok
	end

	with :ok <- head_check, do: Pleroma.HTTP.get(url, headers, @options)
	end

	defp check_content_type(headers) do
	case List.keyfind(headers, "content-type", 0) do
	{_, content_type} ->
	case Plug.Conn.Utils.media_type(content_type) do
	{:ok, "text", "html", _} -> :ok
	_ -> {:error, {:content_type, content_type}}
	end

	_ ->
	:ok
	end
	end

	@max_body @options[:max_body]
	defp check_content_length(headers) do
	case List.keyfind(headers, "content-length", 0) do
	{_, maybe_content_length} ->
	case Integer.parse(maybe_content_length) do
	{content_length, ""} when content_length <= @max_body -> :ok
	{_, ""} -> {:error, :body_too_large}
	_ -> :ok
	end

	_ ->
	:ok
	end
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parser.ex b/lib/pleroma/web/rich_media/parser.ex
	index 837182d8a..a73fbc4b9 100644
	--- a/lib/pleroma/web/rich_media/parser.ex
	+++ b/lib/pleroma/web/rich_media/parser.ex
	@@ -1,169 +1,208 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser do
	require Logger

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+ @config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)

	defp parsers do
	Pleroma.Config.get([:rich_media, :parsers])
	end

	def parse(nil), do: {:error, "No URL provided"}

	- if Pleroma.Config.get(:env) == :test do
	- @spec parse(String.t()) :: {:ok, map()} \| {:error, any()}
	- def parse(url), do: parse_url(url)
	- else
	- @spec parse(String.t()) :: {:ok, map()} \| {:error, any()}
	- def parse(url) do
	- with {:ok, data} <- get_cached_or_parse(url),
	- {:ok, _} <- set_ttl_based_on_image(data, url) do
	- {:ok, data}
	- end
	+ @spec parse(String.t()) :: {:ok, map()} \| {:error, any()}
	+ def parse(url) do
	+ with :ok <- validate_page_url(url),
	+ {:ok, data} <- get_cached_or_parse(url),
	+ {:ok, _} <- set_ttl_based_on_image(data, url) do
	+ {:ok, data}
	end
	+ end

	- defp get_cached_or_parse(url) do
	- case @cachex.fetch(:rich_media_cache, url, fn ->
	- case parse_url(url) do
	- {:ok, _} = res ->
	- {:commit, res}
	-
	- {:error, reason} = e ->
	- # Unfortunately we have to log errors here, instead of doing that
	- # along with ttl setting at the bottom. Otherwise we can get log spam
	- # if more than one process was waiting for the rich media card
	- # while it was generated. Ideally we would set ttl here as well,
	- # so we don't override it number_of_waiters_on_generation
	- # times, but one, obviously, can't set ttl for not-yet-created entry
	- # and Cachex doesn't support returning ttl from the fetch callback.
	- log_error(url, reason)
	- {:commit, e}
	- end
	- end) do
	- {action, res} when action in [:commit, :ok] ->
	- case res do
	- {:ok, _data} = res ->
	- res
	-
	- {:error, reason} = e ->
	- if action == :commit, do: set_error_ttl(url, reason)
	- e
	- end
	-
	- {:error, e} ->
	- {:error, {:cachex_error, e}}
	- end
	+ defp get_cached_or_parse(url) do
	+ case @cachex.fetch(:rich_media_cache, url, fn ->
	+ case parse_url(url) do
	+ {:ok, _} = res ->
	+ {:commit, res}
	+
	+ {:error, reason} = e ->
	+ # Unfortunately we have to log errors here, instead of doing that
	+ # along with ttl setting at the bottom. Otherwise we can get log spam
	+ # if more than one process was waiting for the rich media card
	+ # while it was generated. Ideally we would set ttl here as well,
	+ # so we don't override it number_of_waiters_on_generation
	+ # times, but one, obviously, can't set ttl for not-yet-created entry
	+ # and Cachex doesn't support returning ttl from the fetch callback.
	+ log_error(url, reason)
	+ {:commit, e}
	+ end
	+ end) do
	+ {action, res} when action in [:commit, :ok] ->
	+ case res do
	+ {:ok, _data} = res ->
	+ res
	+
	+ {:error, reason} = e ->
	+ if action == :commit, do: set_error_ttl(url, reason)
	+ e
	+ end
	+
	+ {:error, e} ->
	+ {:error, {:cachex_error, e}}
	end
	+ end

	- defp set_error_ttl(_url, :body_too_large), do: :ok
	- defp set_error_ttl(_url, {:content_type, _}), do: :ok
	+ defp set_error_ttl(_url, :body_too_large), do: :ok
	+ defp set_error_ttl(_url, {:content_type, _}), do: :ok

	- # The TTL is not set for the errors above, since they are unlikely to change
	- # with time
	+ # The TTL is not set for the errors above, since they are unlikely to change
	+ # with time

	- defp set_error_ttl(url, _reason) do
	- ttl = Pleroma.Config.get([:rich_media, :failure_backoff], 60_000)
	- @cachex.expire(:rich_media_cache, url, ttl)
	- :ok
	- end
	+ defp set_error_ttl(url, _reason) do
	+ ttl = Pleroma.Config.get([:rich_media, :failure_backoff], 60_000)
	+ @cachex.expire(:rich_media_cache, url, ttl)
	+ :ok
	+ end

	- defp log_error(url, {:invalid_metadata, data}) do
	- Logger.debug(fn -> "Incomplete or invalid metadata for #{url}: #{inspect(data)}" end)
	- end
	+ defp log_error(url, {:invalid_metadata, data}) do
	+ Logger.debug(fn -> "Incomplete or invalid metadata for #{url}: #{inspect(data)}" end)
	+ end

	- defp log_error(url, reason) do
	- Logger.warning(fn -> "Rich media error for #{url}: #{inspect(reason)}" end)
	- end
	+ defp log_error(url, reason) do
	+ Logger.warning(fn -> "Rich media error for #{url}: #{inspect(reason)}" end)
	end

	@doc """
	Set the rich media cache based on the expiration time of image.

	Adopt behaviour `Pleroma.Web.RichMedia.Parser.TTL`

	## Example

	defmodule MyModule do
	@behaviour Pleroma.Web.RichMedia.Parser.TTL
	def ttl(data, url) do
	image_url = Map.get(data, :image)
	# do some parsing in the url and get the ttl of the image
	# and return ttl is unix time
	parse_ttl_from_url(image_url)
	end
	end

	Define the module in the config

	config :pleroma, :rich_media,
	ttl_setters: [MyModule]
	"""
	@spec set_ttl_based_on_image(map(), String.t()) ::
	{:ok, integer() \| :noop} \| {:error, :no_key}
	def set_ttl_based_on_image(data, url) do
	case get_ttl_from_image(data, url) do
	ttl when is_number(ttl) ->
	ttl = ttl * 1000

	case @cachex.expire_at(:rich_media_cache, url, ttl) do
	{:ok, true} -> {:ok, ttl}
	{:ok, false} -> {:error, :no_key}
	end

	_ ->
	{:ok, :noop}
	end
	end

	defp get_ttl_from_image(data, url) do
	[:rich_media, :ttl_setters]
	\|> Pleroma.Config.get()
	\|> Enum.reduce({:ok, nil}, fn
	module, {:ok, _ttl} ->
	module.ttl(data, url)

	_, error ->
	error
	end)
	end

	def parse_url(url) do
	with {:ok, %Tesla.Env{body: html}} <- Pleroma.Web.RichMedia.Helpers.rich_media_get(url),
	{:ok, html} <- Floki.parse_document(html) do
	html
	\|> maybe_parse()
	\|> Map.put("url", url)
	\|> clean_parsed_data()
	\|> check_parsed_data()
	end
	end

	defp maybe_parse(html) do
	Enum.reduce_while(parsers(), %{}, fn parser, acc ->
	case parser.parse(html, acc) do
	data when data != %{} -> {:halt, data}
	_ -> {:cont, acc}
	end
	end)
	end

	defp check_parsed_data(%{"title" => title} = data)
	when is_binary(title) and title != "" do
	{:ok, data}
	end

	defp check_parsed_data(data) do
	{:error, {:invalid_metadata, data}}
	end

	defp clean_parsed_data(data) do
	data
	\|> Enum.reject(fn {key, val} ->
	not match?({:ok, _}, Jason.encode(%{key => val}))
	end)
	\|> Map.new()
	end
	+
	+ @spec validate_page_url(URI.t() \| binary()) :: :ok \| :error
	+ defp validate_page_url(page_url) when is_binary(page_url) do
	+ validate_tld = @config_impl.get([Pleroma.Formatter, :validate_tld])
	+
	+ page_url
	+ \|> Linkify.Parser.url?(validate_tld: validate_tld)
	+ \|> parse_uri(page_url)
	+ end
	+
	+ defp validate_page_url(%URI{host: host, scheme: "https"}) do
	+ cond do
	+ Linkify.Parser.ip?(host) ->
	+ :error
	+
	+ host in @config_impl.get([:rich_media, :ignore_hosts], []) ->
	+ :error
	+
	+ get_tld(host) in @config_impl.get([:rich_media, :ignore_tld], []) ->
	+ :error
	+
	+ true ->
	+ :ok
	+ end
	+ end
	+
	+ defp validate_page_url(_), do: :error
	+
	+ defp parse_uri(true, url) do
	+ url
	+ \|> URI.parse()
	+ \|> validate_page_url
	+ end
	+
	+ defp parse_uri(_, _), do: :error
	+
	+ defp get_tld(host) do
	+ host
	+ \|> String.split(".")
	+ \|> Enum.reverse()
	+ \|> hd
	+ end
	end
	diff --git a/test/fixtures/rich_media/oembed.html b/test/fixtures/rich_media/oembed.html
	index 55f17004b..5429630d0 100644
	--- a/test/fixtures/rich_media/oembed.html
	+++ b/test/fixtures/rich_media/oembed.html
	@@ -1,3 +1,3 @@
	<link rel="alternate" type="application/json+oembed"
	- href="http://example.com/oembed.json"
	+ href="https://example.com/oembed.json"
	title="Bacon Lollys oEmbed Profile" />
	diff --git a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	index 7bbe46cbe..f95f15ec3 100644
	--- a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	@@ -1,2559 +1,2553 @@
	# 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.StatusControllerTest do
	use Pleroma.Web.ConnCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.ModerationLog
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.Tests.Helpers
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.ScheduledActivityWorker

	import Mox
	import Pleroma.Factory

	setup do: clear_config([:instance, :federating])
	setup do: clear_config([:instance, :allow_relay])
	setup do: clear_config([:mrf, :policies])
	setup do: clear_config([:mrf_keyword, :reject])

	setup do
	Pleroma.UnstubbedConfigMock
	\|> stub_with(Pleroma.Config)

	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> false
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	:ok
	end

	describe "posting statuses" do
	setup do: oauth_access(["write:statuses"])

	test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
	clear_config([:instance, :federating], true)
	clear_config([:instance, :allow_relay], true)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"content_type" => "text/plain",
	"source" => "Pleroma FE",
	"status" => "Hello world",
	"visibility" => "public"
	})
	\|> json_response_and_validate_schema(200)

	assert response["reblogs_count"] == 0
	ObanHelpers.perform_all()

	response =
	conn
	\|> get("/api/v1/statuses/#{response["id"]}", %{})
	\|> json_response_and_validate_schema(200)

	assert response["reblogs_count"] == 0
	end

	test "posting a status", %{conn: conn} do
	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "0"
	})

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response_and_validate_schema(conn_one, 200)

	assert Activity.get_by_id(id)

	conn_two =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => 0
	})

	# Idempotency plug response means detection fail
	assert %{"id" => second_id} = json_response(conn_two, 200)
	assert id == second_id

	conn_three =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "False"
	})

	assert %{"id" => third_id} = json_response_and_validate_schema(conn_three, 200)
	refute id == third_id

	# An activity that will expire:
	# 2 hours
	expires_in = 2 * 60 * 60

	expires_at = DateTime.add(DateTime.utc_now(), expires_in)

	conn_four =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})

	assert %{"id" => fourth_id} = json_response_and_validate_schema(conn_four, 200)

	assert Activity.get_by_id(fourth_id)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: fourth_id},
	scheduled_at: expires_at
	)
	end

	test "posting a quote post", %{conn: conn} do
	user = insert(:user)

	{:ok, %{id: activity_id} = activity} = CommonAPI.post(user, %{status: "yolo"})
	%{data: %{"id" => quote_url}} = Object.normalize(activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "indeed",
	"quote_id" => activity_id
	})

	assert %{
	"id" => id,
	"pleroma" => %{"quote" => %{"id" => ^activity_id}, "quote_url" => ^quote_url}
	} = json_response_and_validate_schema(conn, 200)

	assert Activity.get_by_id(id)
	end

	test "it fails to create a status if `expires_in` is less or equal than an hour", %{
	conn: conn
	} do
	# 1 minute
	expires_in = 1 * 60

	assert %{"error" => "Expiry date is too soon"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response_and_validate_schema(422)

	# 5 minutes
	expires_in = 5 * 60

	assert %{"error" => "Expiry date is too soon"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response_and_validate_schema(422)
	end

	test "Get MRF reason when posting a status is rejected by one", %{conn: conn} do
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "GNO/Linux"})
	\|> json_response_and_validate_schema(422)
	end

	test "posting an undefined status with an attachment", %{user: user, conn: conn} do
	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)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)]
	})

	assert json_response_and_validate_schema(conn, 200)
	end

	test "replying to a status", %{user: user, conn: conn} do
	{:ok, replied_to} = CommonAPI.post(user, %{status: "cofe"})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity.data["context"] == replied_to.data["context"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
	end

	test "replying to a direct message with visibility other than direct", %{
	user: user,
	conn: conn
	} do
	{:ok, replied_to} = CommonAPI.post(user, %{status: "suya..", visibility: "direct"})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "@#{user.nickname} hey",
	"in_reply_to_id" => replied_to.id,
	"visibility" => visibility
	})

	assert json_response_and_validate_schema(conn, 422) == %{
	"error" => "The message visibility must be direct"
	}
	end)
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a sensitive status", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} =
	json_response_and_validate_schema(conn, 200)

	assert Activity.get_by_id(id)
	end

	test "posting a fake status", %{conn: conn} do
	real_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
	})

	real_status = json_response_and_validate_schema(real_conn, 200)

	assert real_status
	assert Object.get_by_ap_id(real_status["uri"])

	real_status =
	real_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "context"], nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	conn
	\|> assign(:user, refresh_record(conn.assigns.user))
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
	"preview" => true
	})

	fake_status = json_response_and_validate_schema(fake_conn, 200)

	assert fake_status
	refute Object.get_by_ap_id(fake_status["uri"])

	fake_status =
	fake_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "context"], nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "fake statuses' preview card is not cached", %{conn: conn} do
	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	- Tesla.Mock.mock(fn
	- %{
	- method: :get,
	- url: "https://example.com/twitter-card"
	- } ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/twitter_card.html")}
	-
	+ Tesla.Mock.mock_global(fn
	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	conn1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/ogp",
	"preview" => true
	})

	conn2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/twitter-card",
	"preview" => true
	})

	assert %{"card" => %{"title" => "The Rock"}} = json_response_and_validate_schema(conn1, 200)

	assert %{"card" => %{"title" => "Small Island Developing States Photo Submission"}} =
	json_response_and_validate_schema(conn2, 200)
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} =
	json_response_and_validate_schema(conn, 200)

	assert Activity.get_by_id(id)
	end

	test "posting a direct status", %{conn: conn} do
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id} = response = json_response_and_validate_schema(conn, 200)
	assert response["visibility"] == "direct"
	assert response["pleroma"]["direct_conversation_id"]
	assert activity = Activity.get_by_id(id)
	assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end

	test "discloses application metadata when enabled" do
	user = insert(:user, disclose_client: true)
	%{user: _user, token: token, conn: conn} = oauth_access(["write:statuses"], user: user)

	%Pleroma.Web.OAuth.Token{
	app: %Pleroma.Web.OAuth.App{
	client_name: app_name,
	website: app_website
	}
	} = token

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "cofe is my copilot"
	})

	assert %{
	"content" => "cofe is my copilot"
	} = json_response_and_validate_schema(result, 200)

	activity = result.assigns.activity.id

	result =
	conn
	\|> get("/api/v1/statuses/#{activity}")

	assert %{
	"content" => "cofe is my copilot",
	"application" => %{
	"name" => ^app_name,
	"website" => ^app_website
	}
	} = json_response_and_validate_schema(result, 200)
	end

	test "hides application metadata when disabled" do
	user = insert(:user, disclose_client: false)
	%{user: _user, token: _token, conn: conn} = oauth_access(["write:statuses"], user: user)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "club mate is my wingman"
	})

	assert %{"content" => "club mate is my wingman"} =
	json_response_and_validate_schema(result, 200)

	activity = result.assigns.activity.id

	result =
	conn
	\|> get("/api/v1/statuses/#{activity}")

	assert %{
	"content" => "club mate is my wingman",
	"application" => nil
	} = json_response_and_validate_schema(result, 200)
	end
	end

	describe "posting scheduled statuses" do
	setup do: oauth_access(["write:statuses"])

	test "creates a scheduled activity", %{conn: conn} do
	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} =
	json_response_and_validate_schema(conn, 200)

	assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
	assert [] == Repo.all(Activity)
	end

	test "with expiration" do
	%{conn: conn} = oauth_access(["write:statuses", "read:statuses"])

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	assert %{"id" => status_id, "params" => %{"expires_in" => 300}} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at,
	"expires_in" => 300
	})
	\|> json_response_and_validate_schema(200)

	assert %{"id" => ^status_id, "params" => %{"expires_in" => 300}} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/scheduled_statuses/#{status_id}")
	\|> json_response_and_validate_schema(200)
	end

	test "ignores nil values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => nil
	})

	assert result = json_response_and_validate_schema(conn, 200)
	assert Activity.get_by_id(result["id"])
	end

	test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
	scheduled_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(120), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	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)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)],
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"media_attachments" => [media_attachment]} =
	json_response_and_validate_schema(conn, 200)

	assert %{"type" => "image"} = media_attachment
	end

	test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
	%{conn: conn} do
	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"content" => "not scheduled"} = json_response_and_validate_schema(conn, 200)
	assert [] == Repo.all(ScheduledActivity)
	end

	test "returns error when daily user limit is exceeded", %{user: user, conn: conn} do
	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	# TODO
	\|> Kernel.<>("Z")

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})

	assert %{"error" => "daily limit exceeded"} == json_response_and_validate_schema(conn, 422)
	end

	test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	tomorrow =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.hours(36), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})

	assert %{"error" => "total limit exceeded"} == json_response_and_validate_schema(conn, 422)
	end
	end

	describe "posting polls" do
	setup do: oauth_access(["write:statuses"])

	test "posting a poll", %{conn: conn} do
	time = NaiveDateTime.utc_now()

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "Who is the #bestgrill?",
	"poll" => %{
	"options" => ["Rei", "Asuka", "Misato"],
	"expires_in" => 420
	}
	})

	response = json_response_and_validate_schema(conn, 200)

	assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
	title in ["Rei", "Asuka", "Misato"]
	end)

	assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
	assert response["poll"]["expired"] == false

	question = Object.get_by_id(response["poll"]["id"])

	# closed contains utc timezone
	assert question.data["closed"] =~ "Z"
	end

	test "option limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_options])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{
	"options" => Enum.map(0..limit, fn num -> "desu #{num}" end),
	"expires_in" => 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll can't contain more than #{limit} options"
	end

	test "option character limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_option_chars])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "...",
	"poll" => %{
	"options" => [String.duplicate(".", limit + 1), "lol"],
	"expires_in" => 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll options cannot be longer than #{limit} characters each"
	end

	test "minimal date limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :min_expiration])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit - 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Expiration date is too soon"
	end

	test "maximum date limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_expiration])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit + 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Expiration date is too far in the future"
	end

	test "scheduled poll", %{conn: conn} do
	clear_config([ScheduledActivity, :enabled], true)

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	%{"id" => scheduled_id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "very cool poll",
	"poll" => %{
	"options" => ~w(a b c),
	"expires_in" => 420
	},
	"scheduled_at" => scheduled_at
	})
	\|> json_response_and_validate_schema(200)

	assert {:ok, %{id: activity_id}} =
	perform_job(ScheduledActivityWorker, %{
	activity_id: scheduled_id
	})

	refute_enqueued(worker: ScheduledActivityWorker)

	object =
	Activity
	\|> Repo.get(activity_id)
	\|> Object.normalize()

	assert object.data["content"] == "very cool poll"
	assert object.data["type"] == "Question"
	assert length(object.data["oneOf"]) == 3
	end

	test "cannot have only one option", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => ["mew"], "expires_in" => 1}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll must contain at least 2 options"
	end

	test "cannot have only duplicated options", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => ["mew", "mew"], "expires_in" => 1}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll must contain at least 2 options"
	end
	end

	test "get a status" do
	%{conn: conn} = oauth_access(["read:statuses"])
	activity = insert(:note_activity)

	conn = get(conn, "/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == to_string(activity.id)
	end

	defp local_and_remote_activities do
	local = insert(:note_activity)
	remote = insert(:note_activity, local: false)
	{:ok, local: local, remote: remote}
	end

	defp local_and_remote_context_activities do
	local_user_1 = insert(:user)
	local_user_2 = insert(:user)
	remote_user = insert(:user, local: false)

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

	{:ok, %{id: id2} = post} =
	CommonAPI.post(local_user_2, %{status: "local reply", in_reply_to_status_id: id1})

	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => remote_user.ap_id,
	"type" => "Create",
	"context" => context,
	"id" => "#{remote_user.ap_id}/activities/1",
	"inReplyTo" => post.data["id"],
	"object" => %{
	"type" => "Note",
	"content" => "remote reply",
	"context" => context,
	"id" => "#{remote_user.ap_id}/objects/1",
	"attributedTo" => remote_user.ap_id,
	"to" => [
	local_user_1.ap_id,
	local_user_2.ap_id,
	"https://www.w3.org/ns/activitystreams#Public"
	]
	},
	"to" => [
	local_user_1.ap_id,
	local_user_2.ap_id,
	"https://www.w3.org/ns/activitystreams#Public"
	]
	}

	{:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
	{:ok, remote_activity} = ObanHelpers.perform(job)

	%{locals: [id1, id2], remote: remote_activity.id, context: context}
	end

	describe "status with restrict unauthenticated activities for local and remote" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}

	res_conn = get(conn, "/api/v1/statuses/#{remote.id}")

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "status with restrict unauthenticated activities for local" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}

	res_conn = get(conn, "/api/v1/statuses/#{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/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "status with restrict unauthenticated activities for remote" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/statuses/#{remote.id}")

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	test "getting a status that doesn't exist returns 404" do
	%{conn: conn} = oauth_access(["read:statuses"])
	activity = insert(:note_activity)

	conn = get(conn, "/api/v1/statuses/#{String.downcase(activity.id)}")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end

	test "get a direct status" do
	%{user: user, conn: conn} = oauth_access(["read:statuses"])
	other_user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}")

	[participation] = Participation.for_user(user)

	res = json_response_and_validate_schema(conn, 200)
	assert res["pleroma"]["direct_conversation_id"] == participation.id
	end

	test "get statuses by IDs" do
	%{conn: conn} = oauth_access(["read:statuses"])
	%{id: id1} = insert(:note_activity)
	%{id: id2} = insert(:note_activity)

	query_string = "ids[]=#{id1}&ids[]=#{id2}"
	conn = get(conn, "/api/v1/statuses/?#{query_string}")

	assert [%{"id" => ^id1}, %{"id" => ^id2}] =
	Enum.sort_by(json_response_and_validate_schema(conn, :ok), & &1["id"])
	end

	describe "getting statuses by ids with restricted unauthenticated for local and remote" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert 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/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "getting statuses by ids with restricted unauthenticated for local" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	remote_id = remote.id
	assert [%{"id" => ^remote_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/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "getting statuses by ids with restricted unauthenticated for remote" do
	setup do: local_and_remote_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	local_id = local.id
	assert [%{"id" => ^local_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/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "getting status contexts restricted unauthenticated for local and remote" do
	setup do: local_and_remote_context_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)

	test "if user is unauthenticated", %{conn: conn, locals: [post_id, _]} do
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	assert json_response_and_validate_schema(res_conn, 200) == %{
	"ancestors" => [],
	"descendants" => []
	}
	end

	test "if user is unauthenticated reply", %{conn: conn, locals: [_, reply_id]} do
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	assert json_response_and_validate_schema(res_conn, 200) == %{
	"ancestors" => [],
	"descendants" => []
	}
	end

	test "if user is authenticated", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in descendant_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is authenticated reply", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id in descendant_ids
	end
	end

	describe "getting status contexts restricted unauthenticated for local" do
	setup do: local_and_remote_context_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], false)

	test "if user is unauthenticated", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id not in descendant_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is unauthenticated reply", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id not in ancestor_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is authenticated", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in descendant_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is authenticated reply", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id in descendant_ids
	end
	end

	describe "getting status contexts restricted unauthenticated for remote" do
	setup do: local_and_remote_context_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], false)

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)

	test "if user is unauthenticated", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in descendant_ids
	assert remote_reply_id not in descendant_ids
	end

	test "if user is unauthenticated reply", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id not in descendant_ids
	end

	test "if user is authenticated", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	reply_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in reply_ids
	assert remote_reply_id in reply_ids
	end

	test "if user is authenticated reply", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id in descendant_ids
	end
	end

	describe "deleting a status" do
	test "when you created it" do
	%{user: author, conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity, user: author)
	object = Object.normalize(activity, fetch: false)

	content = object.data["content"]
	source = object.data["source"]

	result =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(200)

	assert match?(%{"content" => ^content, "text" => ^source}, result)

	refute Activity.get_by_id(activity.id)
	end

	test "when it doesn't exist" do
	%{user: author, conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity, user: author)

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{String.downcase(activity.id)}")

	assert %{"error" => "Record not found"} == json_response_and_validate_schema(conn, 404)
	end

	test "when you didn't create it" do
	%{conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity)

	conn = delete(conn, "/api/v1/statuses/#{activity.id}")

	assert %{"error" => "Record not found"} == json_response_and_validate_schema(conn, 404)

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're privileged to", %{conn: conn} do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	activity = insert(:note_activity)
	user = insert(:user, is_moderator: true)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	assert ModerationLog \|> Repo.one() \|> ModerationLog.get_log_entry_message() ==
	"@#{user.nickname} deleted status ##{activity.id}"

	refute Activity.get_by_id(activity.id)
	end

	test "when you're privileged and the user is banned", %{conn: conn} do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	posting_user = insert(:user, is_active: false)
	refute posting_user.is_active
	activity = insert(:note_activity, user: posting_user)
	user = insert(:user, is_moderator: true)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	assert ModerationLog \|> Repo.one() \|> ModerationLog.get_log_entry_message() ==
	"@#{user.nickname} deleted status ##{activity.id}"

	refute Activity.get_by_id(activity.id)
	end
	end

	describe "reblogging" do
	setup do: oauth_access(["write:statuses"])

	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true
	} = json_response_and_validate_schema(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{String.downcase(activity.id)}/reblog")

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
	end

	test "reblogs privately and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/v1/statuses/#{activity.id}/reblog",
	%{"visibility" => "private"}
	)

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true,
	"visibility" => "private"
	} = json_response_and_validate_schema(conn, 200)

	assert to_string(activity.id) == id
	end

	test "reblogged status for another user" do
	activity = insert(:note_activity)
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	{:ok, _} = CommonAPI.favorite(user2, activity.id)
	{:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
	{:ok, reblog_activity1} = CommonAPI.repeat(activity.id, user1)
	{:ok, _} = CommonAPI.repeat(activity.id, user2)

	conn_res =
	build_conn()
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
	\|> get("/api/v1/statuses/#{reblog_activity1.id}")

	assert %{
	"reblog" => %{"id" => _id, "reblogged" => false, "reblogs_count" => 2},
	"reblogged" => false,
	"favourited" => false,
	"bookmarked" => false
	} = json_response_and_validate_schema(conn_res, 200)

	conn_res =
	build_conn()
	\|> assign(:user, user2)
	\|> assign(:token, insert(:oauth_token, user: user2, scopes: ["read:statuses"]))
	\|> get("/api/v1/statuses/#{reblog_activity1.id}")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
	"reblogged" => true,
	"favourited" => true,
	"bookmarked" => true
	} = json_response_and_validate_schema(conn_res, 200)

	assert to_string(activity.id) == id
	end

	test "author can reblog own private status", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true,
	"visibility" => "private"
	} = json_response_and_validate_schema(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "unreblogging" do
	setup do: oauth_access(["write:statuses"])

	test "unreblogs and returns the unreblogged status", %{user: user, conn: conn} do
	activity = insert(:note_activity)

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} =
	json_response_and_validate_schema(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 404 error when activity does not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/foo/unreblog")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "favoriting" do
	setup do: oauth_access(["write:favourites"])

	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response_and_validate_schema(conn, 200)

	assert to_string(activity.id) == id
	end

	test "favoriting twice will just return 200", %{conn: conn} do
	activity = insert(:note_activity)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")
	\|> json_response_and_validate_schema(200)
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/favourite")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "unfavoriting" do
	setup do: oauth_access(["write:favourites"])

	test "unfavorites a status and returns it", %{user: user, conn: conn} do
	activity = insert(:note_activity)

	{:ok, _} = CommonAPI.favorite(user, activity.id)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response_and_validate_schema(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/unfavourite")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "pinned statuses" do
	setup do: oauth_access(["write:accounts"])

	setup %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})

	%{activity: activity}
	end

	setup do: clear_config([:instance, :max_pinned_statuses], 1)

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id = activity.id

	assert %{"id" => ^id, "pinned" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end

	test "non authenticated user", %{activity: activity} do
	assert build_conn()
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(403) == %{"error" => "Invalid credentials."}
	end

	test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
	{:ok, dm} = CommonAPI.post(user, %{status: "test", visibility: "direct"})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{dm.id}/pin")

	assert json_response_and_validate_schema(conn, 422) == %{
	"error" => "Non-public status cannot be pinned"
	}
	end

	test "pin by another user", %{activity: activity} do
	%{conn: conn} = oauth_access(["write:accounts"])

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(422) == %{"error" => "Someone else's status cannot be pinned"}
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)
	user = refresh_record(user)

	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response_and_validate_schema(200)

	assert [] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end

	test "/unpin: returns 404 error when activity doesn't exist", %{conn: conn} do
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/unpin")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response_and_validate_schema(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response_and_validate_schema(400)
	end

	test "on pin removes deletion job, on unpin reschedule deletion" do
	%{conn: conn} = oauth_access(["write:accounts", "write:statuses"])
	expires_in = 2 * 60 * 60

	expires_at = DateTime.add(DateTime.utc_now(), expires_in)

	assert %{"id" => id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response_and_validate_schema(200)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: id},
	scheduled_at: expires_at
	)

	assert %{"id" => ^id, "pinned" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{id}/pin")
	\|> json_response_and_validate_schema(200)

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

	assert %{"id" => ^id, "pinned" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{id}/unpin")
	\|> json_response_and_validate_schema(200)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: id},
	scheduled_at: expires_at
	)
	end
	end

	describe "cards" do
	setup do
	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	oauth_access(["read:statuses"])
	end

	test "returns rich-media card", %{conn: conn, user: user} do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	{:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp"})

	card_data = %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
	}
	}
	}

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response_and_validate_schema(200)

	assert response == card_data

	# works with private posts
	{:ok, activity} =
	CommonAPI.post(user, %{status: "https://example.com/ogp", visibility: "direct"})

	response_two =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response_and_validate_schema(200)

	assert response_two == card_data
	end

	test "replaces missing description with an empty string", %{conn: conn, user: user} do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	{:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp-missing-data"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response_and_validate_schema(:ok)

	assert response == %{
	"type" => "link",
	"title" => "Pleroma",
	"description" => "",
	"image" => nil,
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"url" => "https://example.com/ogp-missing-data",
	"pleroma" => %{
	"opengraph" => %{
	"title" => "Pleroma",
	"type" => "website",
	"url" => "https://example.com/ogp-missing-data"
	}
	}
	}
	end
	end

	test "bookmarks" do
	bookmarks_uri = "/api/v1/bookmarks"

	%{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
	author = insert(:user)

	{:ok, activity1} = CommonAPI.post(author, %{status: "heweoo?"})
	{:ok, activity2} = CommonAPI.post(author, %{status: "heweoo!"})

	response1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response_and_validate_schema(response1, 200)["bookmarked"] == true

	response2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response_and_validate_schema(response2, 200)["bookmarked"] == true

	bookmarks = get(conn, bookmarks_uri)

	assert [
	json_response_and_validate_schema(response2, 200),
	json_response_and_validate_schema(response1, 200)
	] ==
	json_response_and_validate_schema(bookmarks, 200)

	response1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response_and_validate_schema(response1, 200)["bookmarked"] == false

	bookmarks = get(conn, bookmarks_uri)

	assert [json_response_and_validate_schema(response2, 200)] ==
	json_response_and_validate_schema(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do: oauth_access(["write:mutes"])

	setup do
	post_user = insert(:user)
	{:ok, activity} = CommonAPI.post(post_user, %{status: "HIE"})
	%{activity: activity}
	end

	test "mute conversation", %{conn: conn, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response_and_validate_schema(200)
	end

	test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/mute")

	assert json_response_and_validate_schema(conn, 400) == %{
	"error" => "conversation is already muted"
	}
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	# \|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, replied_to} = CommonAPI.post(user1, %{status: "cofe"})

	# Reply to status from another user
	conn1 =
	conn
	\|> assign(:user, user2)
	\|> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn1, 200)

	activity = Activity.get_by_id_with_object(id)

	assert Object.normalize(activity, fetch: false).data["inReplyTo"] ==
	Object.normalize(replied_to, fetch: false).data["id"]

	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id

	# Reblog from the third user
	conn2 =
	conn
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response_and_validate_schema(conn2, 200)

	assert to_string(activity.id) == id

	# Getting third user status
	conn3 =
	conn
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
	\|> get("/api/v1/timelines/home")

	[reblogged_activity] = json_response_and_validate_schema(conn3, 200)

	assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id

	replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
	assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
	end

	describe "GET /api/v1/statuses/:id/favourited_by" do
	setup do: oauth_access(["read:accounts"])

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

	%{activity: activity}
	end

	test "returns users who have favorited the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been favorited yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have favorited the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, other_user)

	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "requires authentication for private posts", %{user: user} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} wanna get some #cofe together?",
	visibility: "direct"
	})

	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	favourited_by_url = "/api/v1/statuses/#{activity.id}/favourited_by"

	build_conn()
	\|> get(favourited_by_url)
	\|> json_response_and_validate_schema(404)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))

	conn
	\|> assign(:token, nil)
	\|> get(favourited_by_url)
	\|> json_response_and_validate_schema(404)

	response =
	conn
	\|> get(favourited_by_url)
	\|> json_response_and_validate_schema(200)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "returns empty array when :show_reactions is disabled", %{conn: conn, activity: activity} do
	clear_config([:instance, :show_reactions], false)

	other_user = insert(:user)
	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end
	end

	describe "GET /api/v1/statuses/:id/reblogged_by" do
	setup do: oauth_access(["read:accounts"])

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

	%{activity: activity}
	end

	test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been reblogged yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, other_user)

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

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status privately", %{
	conn: conn
	} do
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "my secret post"})

	{:ok, _} = CommonAPI.repeat(activity.id, other_user, %{visibility: "private"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "requires authentication for private posts", %{user: user} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} wanna get some #cofe together?",
	visibility: "direct"
	})

	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(404)

	response =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(200)

	assert [] == response
	end
	end

	test "context" do
	user = insert(:user)

	{:ok, %{id: id1}} = CommonAPI.post(user, %{status: "1"})
	{:ok, %{id: id2}} = CommonAPI.post(user, %{status: "2", in_reply_to_status_id: id1})
	{:ok, %{id: id3}} = CommonAPI.post(user, %{status: "3", in_reply_to_status_id: id2})
	{:ok, %{id: id4}} = CommonAPI.post(user, %{status: "4", in_reply_to_status_id: id3})
	{:ok, %{id: id5}} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{id3}/context")
	\|> json_response_and_validate_schema(:ok)

	assert %{
	"ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
	"descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
	} = response
	end

	test "favorites paginate correctly" do
	%{user: user, conn: conn} = oauth_access(["read:favourites"])
	other_user = insert(:user)
	{:ok, first_post} = CommonAPI.post(other_user, %{status: "bla"})
	{:ok, second_post} = CommonAPI.post(other_user, %{status: "bla"})
	{:ok, third_post} = CommonAPI.post(other_user, %{status: "bla"})

	{:ok, _first_favorite} = CommonAPI.favorite(user, third_post.id)
	{:ok, _second_favorite} = CommonAPI.favorite(user, first_post.id)
	{:ok, third_favorite} = CommonAPI.favorite(user, second_post.id)

	result =
	conn
	\|> get("/api/v1/favourites?limit=1")

	assert [%{"id" => post_id}] = json_response_and_validate_schema(result, 200)
	assert post_id == second_post.id

	# Using the header for pagination works correctly
	[next, _] = get_resp_header(result, "link") \|> hd() \|> String.split(", ")
	[next_url, _next_rel] = String.split(next, ";")
	next_url = String.trim_trailing(next_url, ">") \|> String.trim_leading("<")

	max_id = Helpers.get_query_parameter(next_url, "max_id")

	assert max_id == third_favorite.id

	result =
	conn
	\|> get("/api/v1/favourites?max_id=#{max_id}")

	assert [%{"id" => first_post_id}, %{"id" => third_post_id}] =
	json_response_and_validate_schema(result, 200)

	assert first_post_id == first_post.id
	assert third_post_id == third_post.id
	end

	test "returns the favorites of a user" do
	%{user: user, conn: conn} = oauth_access(["read:favourites"])
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{status: "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{status: "trees are happy"})

	{:ok, last_like} = CommonAPI.favorite(user, activity.id)

	first_conn = get(conn, "/api/v1/favourites")

	assert [status] = json_response_and_validate_schema(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	status: "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

	{:ok, _} = CommonAPI.favorite(user, second_activity.id)

	second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like.id}")

	assert [second_status] = json_response_and_validate_schema(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn = get(conn, "/api/v1/favourites?limit=0")

	assert [] = json_response_and_validate_schema(third_conn, 200)
	end

	test "expires_at is nil for another user" do
	%{conn: conn, user: user} = oauth_access(["read:statuses"])
	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)
	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", expires_in: 1_000_000})

	assert %{"pleroma" => %{"expires_at" => a_expires_at}} =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:ok)

	{:ok, a_expires_at, 0} = DateTime.from_iso8601(a_expires_at)
	assert DateTime.diff(expires_at, a_expires_at) == 0

	%{conn: conn} = oauth_access(["read:statuses"])

	assert %{"pleroma" => %{"expires_at" => nil}} =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:ok)
	end

	describe "local-only statuses" do
	test "posting a local only status" do
	%{user: _user, conn: conn} = oauth_access(["write:statuses"])

	conn_one =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"visibility" => "local"
	})

	local = Utils.as_local_public()

	assert %{"content" => "cofe", "id" => id, "visibility" => "local"} =
	json_response_and_validate_schema(conn_one, 200)

	assert %Activity{id: ^id, data: %{"to" => [^local]}} = Activity.get_by_id(id)
	end

	test "other users can read local-only posts" do
	user = insert(:user)
	%{user: _reader, conn: conn} = oauth_access(["read:statuses"])

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

	received =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:ok)

	assert received["id"] == activity.id
	end

	test "anonymous users cannot see local-only posts" do
	user = insert(:user)

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

	_received =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:not_found)
	end
	end

	describe "muted reactions" do
	test "index" do
	%{conn: conn, user: user} = oauth_access(["read:statuses"])

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/statuses/?ids[]=#{activity.id}")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/statuses/?ids[]=#{activity.id}&with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "show" do
	# %{conn: conn, user: user, token: token} = oauth_access(["read:statuses"])
	%{conn: conn, user: user, token: _token} = oauth_access(["read:statuses"])

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(200)

	assert %{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	} = result

	result =
	conn
	\|> get("/api/v1/statuses/#{activity.id}?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert %{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	} = result
	end
	end

	describe "get status history" do
	setup do
	%{conn: build_conn()}
	end

	test "unedited post", %{conn: conn} do
	activity = insert(:note_activity)

	conn = get(conn, "/api/v1/statuses/#{activity.id}/history")

	assert [_] = json_response_and_validate_schema(conn, 200)
	end

	test "edited post", %{conn: conn} do
	note =
	insert(
	:note,
	data: %{
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "mew mew 2",
	"summary" => "title 2"
	},
	%{
	"type" => "Note",
	"content" => "mew mew 1",
	"summary" => "title 1"
	}
	],
	"totalItems" => 2
	}
	}
	)

	activity = insert(:note_activity, note: note)

	conn = get(conn, "/api/v1/statuses/#{activity.id}/history")

	assert [%{"spoiler_text" => "title 1"}, %{"spoiler_text" => "title 2"}, _] =
	json_response_and_validate_schema(conn, 200)
	end
	end

	describe "get status source" do
	setup do
	%{conn: build_conn()}
	end

	test "it returns the source", %{conn: conn} do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew mew #abc", spoiler_text: "#def"})

	conn = get(conn, "/api/v1/statuses/#{activity.id}/source")

	id = activity.id

	assert %{"id" => ^id, "text" => "mew mew #abc", "spoiler_text" => "#def"} =
	json_response_and_validate_schema(conn, 200)
	end
	end

	describe "update status" do
	setup do
	oauth_access(["write:statuses"])
	end

	test "it updates the status" do
	%{conn: conn, user: user} = oauth_access(["write:statuses", "read:statuses"])

	{:ok, activity} = CommonAPI.post(user, %{status: "mew mew #abc", spoiler_text: "#def"})

	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(200)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(200)

	assert response["content"] == "edited"
	assert response["spoiler_text"] == "lol"

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(200)

	assert response["content"] == "edited"
	assert response["spoiler_text"] == "lol"
	end

	test "it updates the attachments", %{conn: conn, user: user} do
	attachment = insert(:attachment, user: user)
	attachment_id = to_string(attachment.id)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew mew #abc", spoiler_text: "#def"})

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "mew mew #abc",
	"spoiler_text" => "#def",
	"media_ids" => [attachment_id]
	})
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^attachment_id}] = response["media_attachments"]
	end

	test "it does not update visibility", %{conn: conn, user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "mew mew #abc",
	spoiler_text: "#def",
	visibility: "private"
	})

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(200)

	assert response["visibility"] == "private"
	end

	test "it refuses to update when original post is not by the user", %{conn: conn} do
	another_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(another_user, %{status: "mew mew #abc", spoiler_text: "#def"})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(:forbidden)
	end

	test "it returns 404 if the user cannot see the post", %{conn: conn} do
	another_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(another_user, %{
	status: "mew mew #abc",
	spoiler_text: "#def",
	visibility: "private"
	})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(:not_found)
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	index 44d40269c..c8b3cb391 100644
	--- a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	@@ -1,94 +1,95 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	import Mox
	import Pleroma.Factory

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

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

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

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

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

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

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

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	id = cm_ref.id

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

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

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

	StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	Tesla.Mock.mock_global(fn
	%{url: "https://example.com/ogp"} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}
	end)

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

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

	cm_ref = MessageReference.for_chat_and_object(chat, object)

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

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

	defmodule Pleroma.Web.RichMedia.HelpersTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.StaticStubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Helpers

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

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

	ConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> false
	path -> Pleroma.Test.StaticConfig.get(path)
	end)
	\|> stub(:get, fn
	path, default -> Pleroma.Test.StaticConfig.get(path, default)
	end)

	:ok
	end

	test "refuses to crawl incomplete URLs" do
	user = insert(:user)

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

	ConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "refuses to crawl malformed URLs" do
	user = insert(:user)

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

	ConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "crawls valid, complete URLs" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](https://example.com/ogp)",
	content_type: "text/markdown"
	})

	ConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	assert %{page_url: "https://example.com/ogp", rich_media: _} =
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "recrawls URLs on updates" do
	original_url = "https://google.com/"
	updated_url = "https://yahoo.com/"

	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

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

	assert match?(
	%{page_url: ^original_url, rich_media: _},
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	)

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

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

	assert match?(
	%{page_url: ^updated_url, rich_media: _},
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	)
	end

	test "refuses to crawl URLs of private network from posts" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "http://127.0.0.1:4000/notice/9kCP7VNyPJXFOXDrgO"})

	{:ok, activity2} = CommonAPI.post(user, %{status: "https://10.111.10.1/notice/9kCP7V"})
	{:ok, activity3} = CommonAPI.post(user, %{status: "https://172.16.32.40/notice/9kCP7V"})
	{:ok, activity4} = CommonAPI.post(user, %{status: "https://192.168.10.40/notice/9kCP7V"})
	{:ok, activity5} = CommonAPI.post(user, %{status: "https://pleroma.local/notice/9kCP7V"})

	ConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	assert %{} == Helpers.fetch_data_for_activity(activity)
	assert %{} == Helpers.fetch_data_for_activity(activity2)
	assert %{} == Helpers.fetch_data_for_activity(activity3)
	assert %{} == Helpers.fetch_data_for_activity(activity4)
	assert %{} == Helpers.fetch_data_for_activity(activity5)
	end
	end
	diff --git a/test/pleroma/web/rich_media/parser_test.exs b/test/pleroma/web/rich_media/parser_test.exs
	index 9064138a6..a05b89a2b 100644
	--- a/test/pleroma/web/rich_media/parser_test.exs
	+++ b/test/pleroma/web/rich_media/parser_test.exs
	@@ -1,176 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.ParserTest do
	- use ExUnit.Case, async: true
	+ use Pleroma.DataCase, async: false

	alias Pleroma.Web.RichMedia.Parser

	- setup do
	- Tesla.Mock.mock(fn
	- %{
	- method: :get,
	- url: "http://example.com/ogp"
	- } ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}
	-
	- %{
	- method: :get,
	- url: "http://example.com/non-ogp"
	- } ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/non_ogp_embed.html")}
	-
	- %{
	- method: :get,
	- url: "http://example.com/ogp-missing-title"
	- } ->
	- %Tesla.Env{
	- status: 200,
	- body: File.read!("test/fixtures/rich_media/ogp-missing-title.html")
	- }
	-
	- %{
	- method: :get,
	- url: "http://example.com/twitter-card"
	- } ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/twitter_card.html")}
	-
	- %{
	- method: :get,
	- url: "http://example.com/oembed"
	- } ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.html")}
	-
	- %{
	- method: :get,
	- url: "http://example.com/oembed.json"
	- } ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.json")}
	-
	- %{method: :get, url: "http://example.com/empty"} ->
	- %Tesla.Env{status: 200, body: "hello"}
	+ import Tesla.Mock

	- %{method: :get, url: "http://example.com/malformed"} ->
	- %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/malformed-data.html")}
	-
	- %{method: :get, url: "http://example.com/error"} ->
	- {:error, :overload}
	-
	- %{
	- method: :head,
	- url: "http://example.com/huge-page"
	- } ->
	- %Tesla.Env{
	- status: 200,
	- headers: [{"content-length", "2000001"}, {"content-type", "text/html"}]
	- }
	-
	- %{
	- method: :head,
	- url: "http://example.com/pdf-file"
	- } ->
	- %Tesla.Env{
	- status: 200,
	- headers: [{"content-length", "1000000"}, {"content-type", "application/pdf"}]
	- }
	-
	- %{method: :head} ->
	- %Tesla.Env{status: 404, body: "", headers: []}
	- end)
	-
	- :ok
	+ setup do
	+ mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	end

	test "returns error when no metadata present" do
	- assert {:error, _} = Parser.parse("http://example.com/empty")
	+ assert {:error, _} = Parser.parse("https://example.com/empty")
	end

	test "doesn't just add a title" do
	- assert {:error, {:invalid_metadata, _}} = Parser.parse("http://example.com/non-ogp")
	+ assert {:error, {:invalid_metadata, _}} = Parser.parse("https://example.com/non-ogp")
	end

	test "parses ogp" do
	- assert Parser.parse("http://example.com/ogp") ==
	+ assert Parser.parse("https://example.com/ogp") ==
	{:ok,
	%{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	"type" => "video.movie",
	- "url" => "http://example.com/ogp"
	+ "url" => "https://example.com/ogp"
	}}
	end

	test "falls back to <title> when ogp:title is missing" do
	- assert Parser.parse("http://example.com/ogp-missing-title") ==
	+ assert Parser.parse("https://example.com/ogp-missing-title") ==
	{:ok,
	%{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock (1996)",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	"type" => "video.movie",
	- "url" => "http://example.com/ogp-missing-title"
	+ "url" => "https://example.com/ogp-missing-title"
	}}
	end

	test "parses twitter card" do
	- assert Parser.parse("http://example.com/twitter-card") ==
	+ assert Parser.parse("https://example.com/twitter-card") ==
	{:ok,
	%{
	"card" => "summary",
	"site" => "@flickr",
	"image" => "https://farm6.staticflickr.com/5510/14338202952_93595258ff_z.jpg",
	"title" => "Small Island Developing States Photo Submission",
	"description" => "View the album on Flickr.",
	- "url" => "http://example.com/twitter-card"
	+ "url" => "https://example.com/twitter-card"
	}}
	end

	test "parses OEmbed and filters HTML tags" do
	- assert Parser.parse("http://example.com/oembed") ==
	+ assert Parser.parse("https://example.com/oembed") ==
	{:ok,
	%{
	"author_name" => "\u202E\u202D\u202Cbees\u202C",
	"author_url" => "https://www.flickr.com/photos/bees/",
	"cache_age" => 3600,
	"flickr_type" => "photo",
	"height" => "768",
	"html" =>
	"<a href=\"https://www.flickr.com/photos/bees/2362225867/\" title=\"Bacon Lollys by \u202E\u202D\u202Cbees\u202C, on Flickr\"><img src=\"https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_b.jpg\" width=\"1024\" height=\"768\" alt=\"Bacon Lollys\"/></a>",
	"license" => "All Rights Reserved",
	"license_id" => 0,
	"provider_name" => "Flickr",
	"provider_url" => "https://www.flickr.com/",
	"thumbnail_height" => 150,
	"thumbnail_url" =>
	"https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_q.jpg",
	"thumbnail_width" => 150,
	"title" => "Bacon Lollys",
	"type" => "photo",
	- "url" => "http://example.com/oembed",
	+ "url" => "https://example.com/oembed",
	"version" => "1.0",
	"web_page" => "https://www.flickr.com/photos/bees/2362225867/",
	"web_page_short_url" => "https://flic.kr/p/4AK2sc",
	"width" => "1024"
	}}
	end

	test "rejects invalid OGP data" do
	- assert {:error, _} = Parser.parse("http://example.com/malformed")
	+ assert {:error, _} = Parser.parse("https://example.com/malformed")
	end

	test "returns error if getting page was not successful" do
	- assert {:error, :overload} = Parser.parse("http://example.com/error")
	+ assert {:error, :overload} = Parser.parse("https://example.com/error")
	end

	test "does a HEAD request to check if the body is too large" do
	- assert {:error, :body_too_large} = Parser.parse("http://example.com/huge-page")
	+ assert {:error, :body_too_large} = Parser.parse("https://example.com/huge-page")
	end

	test "does a HEAD request to check if the body is html" do
	- assert {:error, {:content_type, _}} = Parser.parse("http://example.com/pdf-file")
	+ assert {:error, {:content_type, _}} = Parser.parse("https://example.com/pdf-file")
	end
	end
	diff --git a/test/support/cachex_proxy.ex b/test/support/cachex_proxy.ex
	index 83ae5610f..8f27986a9 100644
	--- a/test/support/cachex_proxy.ex
	+++ b/test/support/cachex_proxy.ex
	@@ -1,40 +1,46 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.CachexProxy do
	@behaviour Pleroma.Caching

	@impl true
	defdelegate get!(cache, key), to: Cachex

	@impl true
	defdelegate stream!(cache, key), to: Cachex

	@impl true
	defdelegate put(cache, key, value, options), to: Cachex

	@impl true
	defdelegate put(cache, key, value), to: Cachex

	@impl true
	defdelegate get_and_update(cache, key, func), to: Cachex

	@impl true
	defdelegate get(cache, key), to: Cachex

	@impl true
	defdelegate fetch!(cache, key, func), to: Cachex

	+ @impl true
	+ defdelegate fetch(cache, key, func), to: Cachex
	+
	@impl true
	defdelegate expire_at(cache, str, num), to: Cachex

	+ @impl true
	+ defdelegate expire(cache, str, num), to: Cachex
	+
	@impl true
	defdelegate exists?(cache, key), to: Cachex

	@impl true
	defdelegate del(cache, key), to: Cachex

	@impl true
	defdelegate execute!(cache, func), to: Cachex
	end
	diff --git a/test/support/http_request_mock.ex b/test/support/http_request_mock.ex
	index df3371a75..f4b6f1f9f 100644
	--- a/test/support/http_request_mock.ex
	+++ b/test/support/http_request_mock.ex
	@@ -1,1563 +1,1618 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule HttpRequestMock do
	require Logger

	def activitypub_object_headers, do: [{"content-type", "application/activity+json"}]

	def request(
	%Tesla.Env{
	url: url,
	method: method,
	headers: headers,
	query: query,
	body: body
	} = _env
	) do
	with {:ok, res} <- apply(__MODULE__, method, [url, query, body, headers]) do
	res
	else
	error ->
	with {:error, message} <- error do
	Logger.warning(to_string(message))
	end

	{_, _r} = error
	end
	end

	# GET Requests
	#
	def get(url, query \\ [], body \\ [], headers \\ [])

	def get("https://osada.macgirvin.com/channel/mike", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___osada.macgirvin.com_channel_mike.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://shitposter.club/users/moonman", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/moonman@shitposter.club.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mastodon.social/users/emelie/statuses/101849165031453009", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/status.emelie.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mastodon.social/users/emelie/statuses/101849165031453404", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def get("https://mastodon.social/users/emelie", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/emelie.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mastodon.social/users/not_found", _, _, _) do
	{:ok, %Tesla.Env{status: 404}}
	end

	def get("https://mastodon.sdf.org/users/rinpatch", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/rinpatch.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mastodon.sdf.org/users/rinpatch/collections/featured", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/users_mock/masto_featured.json")
	\|> String.replace("{{domain}}", "mastodon.sdf.org")
	\|> String.replace("{{nickname}}", "rinpatch"),
	headers: [{"content-type", "application/activity+json"}]
	}}
	end

	def get("https://patch.cx/objects/tesla_mock/poll_attachment", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/poll_attachment.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=https://mastodon.social/users/emelie",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/webfinger_emelie.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get(
	"https://osada.macgirvin.com/.well-known/webfinger?resource=acct:mike@osada.macgirvin.com",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mike@osada.macgirvin.com.json"),
	headers: [{"content-type", "application/jrd+json"}]
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/29191",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___social.heldscal.la_user_29191.xml")
	}}
	end

	def get(
	"https://pawoo.net/.well-known/webfinger?resource=acct:https://pawoo.net/users/pekorino",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___pawoo.net_users_pekorino.xml")
	}}
	end

	def get(
	"https://social.stopwatchingus-heidelberg.de/.well-known/webfinger?resource=acct:https://social.stopwatchingus-heidelberg.de/user/18330",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/atarifrosch_webfinger.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=nonexistent@social.heldscal.la",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/nonexistent@social.heldscal.la.xml")
	}}
	end

	def get(
	"https://squeet.me/xrd/?uri=acct:lain@squeet.me",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/lain_squeet.me_webfinger.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}
	end

	def get(
	"https://mst3k.interlinked.me/users/luciferMysticus",
	_,
	_,
	[{"accept", "application/activity+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/lucifermysticus.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://prismo.news/@mxb", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___prismo.news__mxb.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get(
	"https://hubzilla.example.org/channel/kaniini",
	_,
	_,
	[{"accept", "application/activity+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/kaniini@hubzilla.example.org.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://niu.moe/users/rye", _, _, [{"accept", "application/activity+json"}]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/rye.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://n1u.moe/users/rye", _, _, [{"accept", "application/activity+json"}]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/rye.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://mastodon.example.org/users/admin/statuses/100787282858396771", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/tesla_mock/http___mastodon.example.org_users_admin_status_1234.json"
	)
	}}
	end

	def get("https://puckipedia.com/", _, _, [{"accept", "application/activity+json"}]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/puckipedia.com.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://peertube.moe/accounts/7even", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/7even.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://peertube.stream/accounts/createurs", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/peertube/actor-person.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/peertube.moe-vid.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://framatube.org/accounts/framasoft", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___framatube.org_accounts_framasoft.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://framatube.org/videos/watch/6050732a-8a7a-43d4-a6cd-809525a1d206", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/framatube.org-video.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://peertube.social/accounts/craigmaloney", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/craigmaloney.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://peertube.social/videos/watch/278d2b7c-0f38-4aaa-afe6-9ecc0c4a34fe", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/peertube-social.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39", _, _, [
	{"accept", "application/activity+json"}
	]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mobilizon.org-event.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mobilizon.org/@tcit", _, _, [{"accept", "application/activity+json"}]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mobilizon.org-user.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://baptiste.gelez.xyz/@/BaptisteGelez", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/baptiste.gelex.xyz-user.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/baptiste.gelex.xyz-article.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://wedistribute.org/wp-json/pterotype/v1/object/85810", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/wedistribute-article.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://wedistribute.org/wp-json/pterotype/v1/actor/-blog", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/wedistribute-user.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://mastodon.example.org/users/admin", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/admin@mastdon.example.org.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://mastodon.example.org/users/relay", _, _, [
	{"accept", "application/activity+json"}
	]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/relay@mastdon.example.org.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://mastodon.example.org/users/gargron", _, _, [
	{"accept", "application/activity+json"}
	]) do
	{:error, :nxdomain}
	end

	def get("https://osada.macgirvin.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def get("http://mastodon.sdf.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/sdf.org_host_meta")
	}}
	end

	def get("https://mastodon.sdf.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/sdf.org_host_meta")
	}}
	end

	def get(
	"https://mastodon.sdf.org/.well-known/webfinger?resource=https://mastodon.sdf.org/users/snowdusk",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/snowdusk@sdf.org_host_meta.json")
	}}
	end

	def get("http://mstdn.jp/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mstdn.jp_host_meta")
	}}
	end

	def get("https://mstdn.jp/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mstdn.jp_host_meta")
	}}
	end

	def get("https://mstdn.jp/.well-known/webfinger?resource=kpherox@mstdn.jp", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/kpherox@mstdn.jp.xml")
	}}
	end

	def get("http://mamot.fr/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mamot.fr_host_meta")
	}}
	end

	def get("https://mamot.fr/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mamot.fr_host_meta")
	}}
	end

	def get("http://pawoo.net/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/pawoo.net_host_meta")
	}}
	end

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

	def get(
	"https://pawoo.net/.well-known/webfinger?resource=https://pawoo.net/users/pekorino",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/pekorino@pawoo.net_host_meta.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://pleroma.soykaf.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/soykaf.com_host_meta")
	}}
	end

	def get("https://pleroma.soykaf.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/soykaf.com_host_meta")
	}}
	end

	def get("http://social.stopwatchingus-heidelberg.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/stopwatchingus-heidelberg.de_host_meta")
	}}
	end

	def get("https://social.stopwatchingus-heidelberg.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/stopwatchingus-heidelberg.de_host_meta")
	}}
	end

	def get(
	"http://mastodon.example.org/@admin/99541947525187367",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-note-object.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://mastodon.example.org/@admin/99541947525187368", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def get("https://shitposter.club/notice/7369654", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/7369654.html")
	}}
	end

	def get("https://mstdn.io/users/mayuutann", _, _, [{"accept", "application/activity+json"}]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mayumayu.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394",
	_,
	_,
	[{"accept", "application/activity+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mayumayupost.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get(url, _, _, [{"accept", "application/xrd+xml,application/jrd+json"}])
	when url in [
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=acct:https://pleroma.soykaf.com/users/lain",
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=https://pleroma.soykaf.com/users/lain"
	] do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___pleroma.soykaf.com_users_lain.xml")
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/1",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___shitposter.club_user_1.xml")
	}}
	end

	def get("https://testing.pleroma.lol/objects/b319022a-4946-44c5-9de9-34801f95507b", _, _, _) do
	{:ok, %Tesla.Env{status: 200}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/5381",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/spc_5381_xrd.xml")
	}}
	end

	def get("http://shitposter.club/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/shitposter.club_host_meta")
	}}
	end

	def get("https://shitposter.club/notice/4027863", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/7369654.html")
	}}
	end

	def get("http://social.sakamoto.gq/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/social.sakamoto.gq_host_meta")
	}}
	end

	def get(
	"https://social.sakamoto.gq/.well-known/webfinger?resource=https://social.sakamoto.gq/users/eal",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/eal_sakamoto.xml")
	}}
	end

	def get("http://mastodon.social/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mastodon.social_host_meta")
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=https://mastodon.social/users/lambadalambda",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/tesla_mock/https___mastodon.social_users_lambadalambda.xml")
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=acct:not_found@mastodon.social",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok, %Tesla.Env{status: 404}}
	end

	def get("http://gs.example.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/gs.example.org_host_meta")
	}}
	end

	def get(
	"http://gs.example.org/.well-known/webfinger?resource=http://gs.example.org:4040/index.php/user/1",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/tesla_mock/http___gs.example.org_4040_index.php_user_1.xml")
	}}
	end

	def get(
	"http://gs.example.org:4040/index.php/user/1",
	_,
	_,
	[{"accept", "application/activity+json"}]
	) do
	{:ok, %Tesla.Env{status: 406, body: ""}}
	end

	def get("https://squeet.me/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/tesla_mock/squeet.me_host_meta")}}
	end

	def get(
	"https://squeet.me/xrd?uri=lain@squeet.me",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/lain_squeet.me_webfinger.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=acct:shp@social.heldscal.la",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/shp@social.heldscal.la.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=acct:invalid_content@social.heldscal.la",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok, %Tesla.Env{status: 200, body: "", headers: [{"content-type", "application/jrd+json"}]}}
	end

	def get("https://framatube.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/framatube.org_host_meta")
	}}
	end

	def get(
	"https://framatube.org/main/xrd?uri=acct:framasoft@framatube.org",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/jrd+json"}],
	body: File.read!("test/fixtures/tesla_mock/framasoft@framatube.org.json")
	}}
	end

	def get("http://gnusocial.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/gnusocial.de_host_meta")
	}}
	end

	def get(
	"http://gnusocial.de/main/xrd?uri=winterdienst@gnusocial.de",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/winterdienst_webfinger.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://status.alpicola.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/status.alpicola.com_host_meta")
	}}
	end

	def get("https://macgirvin.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/macgirvin.com_host_meta")
	}}
	end

	def get("https://gerzilla.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/gerzilla.de_host_meta")
	}}
	end

	def get(
	"https://gerzilla.de/xrd/?uri=acct:kaniini@gerzilla.de",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/jrd+json"}],
	body: File.read!("test/fixtures/tesla_mock/kaniini@gerzilla.de.json")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/23211",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___social.heldscal.la_user_23211.xml")
	}}
	end

	def get("http://social.heldscal.la/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("https://social.heldscal.la/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("https://mastodon.social/users/lambadalambda", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/lambadalambda.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mastodon.social/users/lambadalambda/collections/featured", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/users_mock/masto_featured.json")
	\|> String.replace("{{domain}}", "mastodon.social")
	\|> String.replace("{{nickname}}", "lambadalambda"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://apfed.club/channel/indio", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/osada-user-indio.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://social.heldscal.la/user/23211", _, _, [{"accept", "application/activity+json"}]) do
	{:ok, Tesla.Mock.json(%{"id" => "https://social.heldscal.la/user/23211"}, status: 200)}
	end

	def get("http://example.com/ogp", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}}
	end

	def get("https://example.com/ogp", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}}
	end

	def get("https://pleroma.local/notice/9kCP7V", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}}
	end

	def get("http://localhost:4001/users/masto_closed/followers", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/masto_closed_followers.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:4001/users/masto_closed/followers?page=1", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/masto_closed_followers_page.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:4001/users/masto_closed/following", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/masto_closed_following.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:4001/users/masto_closed/following?page=1", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/masto_closed_following_page.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:8080/followers/fuser3", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/friendica_followers.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:8080/following/fuser3", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/friendica_following.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:4001/users/fuser2/followers", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/pleroma_followers.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:4001/users/fuser2/following", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/users_mock/pleroma_following.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://domain-with-errors:4001/users/fuser1/followers", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 504,
	body: ""
	}}
	end

	def get("http://domain-with-errors:4001/users/fuser1/following", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 504,
	body: ""
	}}
	end

	def get("http://example.com/ogp-missing-data", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/rich_media/ogp-missing-data.html")
	}}
	end

	def get("https://example.com/ogp-missing-data", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/rich_media/ogp-missing-data.html")
	}}
	end

	- def get("http://example.com/malformed", _, _, _) do
	+ def get("https://example.com/malformed", _, _, _) do
	{:ok,
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/malformed-data.html")}}
	end

	def get("http://example.com/empty", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: "hello"}}
	end

	def get("http://404.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def get("https://404.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def get(
	"https://zetsubou.xn--q9jyb4c/.well-known/webfinger?resource=acct:lain@zetsubou.xn--q9jyb4c",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/lain.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}
	end

	def get(
	"https://zetsubou.xn--q9jyb4c/.well-known/webfinger?resource=acct:https://zetsubou.xn--q9jyb4c/users/lain",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/lain.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}
	end

	def get("http://zetsubou.xn--q9jyb4c/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/host-meta-zetsubou.xn--q9jyb4c.xml")
	}}
	end

	def get(
	"https://zetsubou.xn--q9jyb4c/.well-known/host-meta",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/host-meta-zetsubou.xn--q9jyb4c.xml")
	}}
	end

	def get("http://lm.kazv.moe/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/lm.kazv.moe_host_meta")
	}}
	end

	def get("https://lm.kazv.moe/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/lm.kazv.moe_host_meta")
	}}
	end

	def get(
	"https://lm.kazv.moe/.well-known/webfinger?resource=acct:mewmew@lm.kazv.moe",
	_,
	_,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___lm.kazv.moe_users_mewmew.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}
	end

	def get("https://lm.kazv.moe/users/mewmew", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mewmew@lm.kazv.moe.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://lm.kazv.moe/users/mewmew/collections/featured", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/users_mock/masto_featured.json")
	\|> String.replace("{{domain}}", "lm.kazv.moe")
	\|> String.replace("{{nickname}}", "mewmew"),
	headers: [{"content-type", "application/activity+json"}]
	}}
	end

	def get("https://info.pleroma.site/activity.json", _, _, [
	{"accept", "application/activity+json"}
	]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https__info.pleroma.site_activity.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://info.pleroma.site/activity.json", _, _, _) do
	{:ok, %Tesla.Env{status: 404, body: ""}}
	end

	def get("https://info.pleroma.site/activity2.json", _, _, [
	{"accept", "application/activity+json"}
	]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https__info.pleroma.site_activity2.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://info.pleroma.site/activity2.json", _, _, _) do
	{:ok, %Tesla.Env{status: 404, body: ""}}
	end

	def get("https://info.pleroma.site/activity3.json", _, _, [
	{"accept", "application/activity+json"}
	]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https__info.pleroma.site_activity3.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://info.pleroma.site/activity3.json", _, _, _) do
	{:ok, %Tesla.Env{status: 404, body: ""}}
	end

	def get("https://mstdn.jp/.well-known/webfinger?resource=acct:kpherox@mstdn.jp", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/kpherox@mstdn.jp.xml"),
	headers: [{"content-type", "application/xrd+xml"}]
	}}
	end

	def get("https://10.111.10.1/notice/9kCP7V", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end

	def get("https://172.16.32.40/notice/9kCP7V", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end

	def get("https://192.168.10.40/notice/9kCP7V", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end

	def get("https://www.patreon.com/posts/mastodon-2-9-and-28121681", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end

	def get("http://mastodon.example.org/@admin/99541947525187367", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-post-activity.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://info.pleroma.site/activity4.json", _, _, _) do
	{:ok, %Tesla.Env{status: 500, body: "Error occurred"}}
	end

	def get("http://example.com/rel_me/anchor", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_anchor.html")}}
	end

	def get("http://example.com/rel_me/anchor_nofollow", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_anchor_nofollow.html")}}
	end

	def get("http://example.com/rel_me/link", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_link.html")}}
	end

	def get("http://example.com/rel_me/null", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_null.html")}}
	end

	def get("https://skippers-bin.com/notes/7x9tmrp97i", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/misskey_poll_no_end_date.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://example.org/emoji/firedfox.png", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/image.jpg")}}
	end

	def get("https://skippers-bin.com/users/7v1w1r8ce6", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/sjw.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://patch.cx/users/rin", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/rin.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get(
	"https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/funkwhale_audio.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://channels.tests.funkwhale.audio/federation/actors/compositions", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/funkwhale_channel.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://example.com/rel_me/error", _, _, _) do
	{:ok, %Tesla.Env{status: 404, body: ""}}
	end

	def get("https://relay.mastodon.host/actor", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/relay/relay.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("http://localhost:4001/", _, "", [{"accept", "text/html"}]) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/tesla_mock/7369654.html")}}
	end

	def get("https://osada.macgirvin.com/", _, "", [{"accept", "text/html"}]) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/https___osada.macgirvin.com.html")
	}}
	end

	def get("https://patch.cx/objects/a399c28e-c821-4820-bc3e-4afeb044c16f", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/emoji-in-summary.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://gleasonator.com/objects/102eb097-a18b-4cd5-abfc-f952efcb70bb", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/gleasonator-AG3RzWfwEKKrY63qj2.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://misskey.io/users/83ssedkv53", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/aimu@misskey.io.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://gleasonator.com/users/macgirvin", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/macgirvin@gleasonator.com.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://gleasonator.com/users/macgirvin/collections/featured", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/users_mock/masto_featured.json")
	\|> String.replace("{{domain}}", "gleasonator.com")
	\|> String.replace("{{nickname}}", "macgirvin"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mk.absturztau.be/users/8ozbzjs3o8", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mametsuko@mk.absturztau.be.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://p.helene.moe/users/helene", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/helene@p.helene.moe.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mk.absturztau.be/notes/93e7nm8wqg", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://mk.absturztau.be/notes/93e7nm8wqg/activity", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/mk.absturztau.be-93e7nm8wqg-activity.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://p.helene.moe/objects/fd5910ac-d9dc-412e-8d1d-914b203296c4", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/p.helene.moe-AM7S6vZQmL6pI9TgPY.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://misskey.io/notes/8vs6wxufd0", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/misskey.io_8vs6wxufd0.json"),
	headers: activitypub_object_headers()
	}}
	end

	def get("https://google.com/", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/google.html")}}
	end

	def get("https://yahoo.com/", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/yahoo.html")}}
	end

	+ def get("https://example.com/error", _, _, _), do: {:error, :overload}
	+
	+ def get("https://example.com/ogp-missing-title", _, _, _) do
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/rich_media/ogp-missing-title.html")
	+ }}
	+ end
	+
	+ def get("https://example.com/oembed", _, _, _) do
	+ {:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.html")}}
	+ end
	+
	+ def get("https://example.com/oembed.json", _, _, _) do
	+ {:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.json")}}
	+ end
	+
	+ def get("https://example.com/twitter-card", _, _, _) do
	+ {:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/twitter_card.html")}}
	+ end
	+
	+ def get("https://example.com/non-ogp", _, _, _) do
	+ {:ok,
	+ %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/non_ogp_embed.html")}}
	+ end
	+
	+ def get("https://example.com/empty", _, _, _) do
	+ {:ok, %Tesla.Env{status: 200, body: "hello"}}
	+ end
	+
	def get(url, query, body, headers) do
	{:error,
	"Mock response not implemented for GET #{inspect(url)}, #{query}, #{inspect(body)}, #{inspect(headers)}"}
	end

	# POST Requests
	#

	def post(url, query \\ [], body \\ [], headers \\ [])

	def post("https://relay.mastodon.host/inbox", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: ""}}
	end

	def post("http://example.org/needs_refresh", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("http://mastodon.example.org/inbox", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("https://hubzilla.example.org/inbox", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("http://gs.example.org/index.php/main/salmon/user/1", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("http://200.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("http://connrefused.site" <> _, _, _, _) do
	{:error, :connrefused}
	end

	def post("http://404.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def post(url, query, body, headers) do
	{:error,
	"Mock response not implemented for POST #{inspect(url)}, #{query}, #{inspect(body)}, #{inspect(headers)}"}
	end

	# Most of the rich media mocks are missing HEAD requests, so we just return 404.
	@rich_media_mocks [
	+ "https://example.com/empty",
	+ "https://example.com/error",
	+ "https://example.com/malformed",
	+ "https://example.com/non-ogp",
	+ "https://example.com/oembed",
	+ "https://example.com/oembed.json",
	"https://example.com/ogp",
	"https://example.com/ogp-missing-data",
	+ "https://example.com/ogp-missing-title",
	"https://example.com/twitter-card",
	"https://google.com/",
	- "https://yahoo.com/",
	- "https://pleroma.local/notice/9kCP7V"
	+ "https://pleroma.local/notice/9kCP7V",
	+ "https://yahoo.com/"
	]
	+
	def head(url, _query, _body, _headers) when url in @rich_media_mocks do
	{:ok, %Tesla.Env{status: 404, body: ""}}
	end

	+ def head("https://example.com/pdf-file", _, _, _) do
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-length", "1000000"}, {"content-type", "application/pdf"}]
	+ }}
	+ end
	+
	+ def head("https://example.com/huge-page", _, _, _) do
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-length", "2000001"}, {"content-type", "text/html"}]
	+ }}
	+ end
	+
	def head(url, query, body, headers) do
	{:error,
	"Mock response not implemented for HEAD #{inspect(url)}, #{query}, #{inspect(body)}, #{inspect(headers)}"}
	end
	end
	diff --git a/test/support/null_cache.ex b/test/support/null_cache.ex
	index 9f1d45f1d..47c84174e 100644
	--- a/test/support/null_cache.ex
	+++ b/test/support/null_cache.ex
	@@ -1,49 +1,55 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NullCache do
	@moduledoc """
	A module simulating a permanently empty cache.
	"""
	@behaviour Pleroma.Caching

	@impl true
	def get!(_, _), do: nil

	@impl true
	def put(_, _, _, _ \\ nil), do: {:ok, true}

	@impl true
	def stream!(_, _), do: []

	@impl true
	def get(_, _), do: {:ok, nil}

	@impl true
	def fetch!(_, key, func) do
	case func.(key) do
	{_, res} -> res
	res -> res
	end
	end

	+ @impl true
	+ def fetch(_, key, func), do: func.(key)
	+
	@impl true
	def get_and_update(_, _, func) do
	func.(nil)
	end

	@impl true
	def expire_at(_, _, _), do: {:ok, true}

	+ @impl true
	+ def expire(_, _, _), do: {:ok, true}
	+
	@impl true
	def exists?(_, _), do: {:ok, false}

	@impl true
	def execute!(_, func) do
	func.(:nothing)
	end

	@impl true
	def del(_, _), do: {:ok, true}
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 8:50 PM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798641
Default Alt Text: (162 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions