No OneTemporary
Actions

Size

100 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/constants.ex b/lib/pleroma/constants.ex
	index bdca8279c..bf92f65cb 100644
	--- a/lib/pleroma/constants.ex
	+++ b/lib/pleroma/constants.ex
	@@ -1,32 +1,30 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Constants do
	use Const

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

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

	const(static_only_files,
	do:
	~w(index.html robots.txt static static-fe finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc embed.js embed.css)
	)
	-
	- def as_local_public, do: Pleroma.Web.Endpoint.url() <> "/#Public"
	end
	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 97b3dad73..724d6374d 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,277 +1,277 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

	This module encodes our addressing policies and general shape of our objects.
	"""

	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.IDs
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	require Pleroma.Constants

	def accept_or_reject(actor, activity, type) do
	data = %{
	"id" => IDs.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => type,
	"object" => activity.data["id"],
	"to" => [activity.actor]
	}

	{:ok, data, []}
	end

	@spec reject(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def reject(actor, rejected_activity) do
	accept_or_reject(actor, rejected_activity, "Reject")
	end

	@spec accept(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def accept(actor, accepted_activity) do
	accept_or_reject(actor, accepted_activity, "Accept")
	end

	@spec follow(User.t(), User.t()) :: {:ok, map(), keyword()}
	def follow(follower, followed) do
	data = %{
	"id" => IDs.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	}

	{:ok, data, []}
	end

	@spec emoji_react(User.t(), Object.t(), String.t()) :: {:ok, map(), keyword()}
	def emoji_react(actor, object, emoji) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("content", emoji)
	\|> Map.put("type", "EmojiReact")

	{:ok, data, meta}
	end
	end

	@spec undo(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def undo(actor, object) do
	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Undo",
	"object" => object.data["id"],
	"to" => object.data["to"] \|\| [],
	"cc" => object.data["cc"] \|\| []
	}, []}
	end

	@spec delete(User.t(), String.t()) :: {:ok, map(), keyword()}
	def delete(actor, object_id) do
	object = Object.normalize(object_id, fetch: false)

	user = !object && User.get_cached_by_ap_id(object_id)

	to =
	case {object, user} do
	{%Object{}, _} ->
	# We are deleting an object, address everyone who was originally mentioned
	(object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	{_, %User{follower_address: follower_address}} ->
	# We are deleting a user, address the followers of that user
	[follower_address]
	end

	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object_id,
	"to" => to,
	"type" => "Delete"
	}, []}
	end

	def create(actor, object, recipients) do
	context =
	if is_map(object) do
	object["context"]
	else
	nil
	end

	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	"object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Pleroma.Maps.put_if_present("context", context), []}
	end

	def chat_message(actor, recipient, content, opts \\ []) do
	basic = %{
	"id" => IDs.generate_object_id(),
	"actor" => actor.ap_id,
	"type" => "ChatMessage",
	"to" => [recipient],
	"content" => content,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"emoji" => Emoji.Formatter.get_emoji_map(content)
	}

	case opts[:attachment] do
	%Object{data: attachment_data} ->
	{
	:ok,
	Map.put(basic, "attachment", attachment_data),
	[]
	}

	_ ->
	{:ok, basic, []}
	end
	end

	def answer(user, object, name) do
	{:ok,
	%{
	"type" => "Answer",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"],
	"context" => object.data["context"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"id" => IDs.generate_object_id()
	}, []}
	end

	@spec tombstone(String.t(), String.t()) :: {:ok, map(), keyword()}
	def tombstone(actor, id) do
	{:ok,
	%{
	"id" => id,
	"actor" => actor,
	"type" => "Tombstone"
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("type", "Like")

	{:ok, data, meta}
	end
	end

	# Retricted to user updates for now, always public
	@spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def update(actor, object) do
	to = [Pleroma.Constants.as_public(), actor.follower_address]

	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"type" => "Update",
	"actor" => actor.ap_id,
	"object" => object,
	"to" => to
	}, []}
	end

	@spec block(User.t(), User.t()) :: {:ok, map(), keyword()}
	def block(blocker, blocked) do
	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"type" => "Block",
	"actor" => blocker.ap_id,
	"object" => blocked.ap_id,
	"to" => [blocked.ap_id]
	}, []}
	end

	@spec announce(User.t(), Object.t(), keyword()) :: {:ok, map(), keyword()}
	def announce(actor, object, options \\ []) do
	public? = Keyword.get(options, :public, false)

	to =
	cond do
	actor.ap_id == Relay.ap_id() ->
	[actor.follower_address]

	public? and Visibility.is_local_public?(object) ->
	- [actor.follower_address, object.data["actor"], Pleroma.Constants.as_local_public()]
	+ [actor.follower_address, object.data["actor"], IDs.as_local_public()]

	public? ->
	[actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()]

	true ->
	[actor.follower_address, object.data["actor"]]
	end

	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"context" => object.data["context"],
	"type" => "Announce",
	"published" => Utils.make_date()
	}, []}
	end

	@spec object_action(User.t(), Object.t()) :: {:ok, map(), keyword()}
	defp object_action(actor, object) do
	object_actor = User.get_cached_by_ap_id(object.data["actor"])

	# Address the actor of the object, and our actor's follower collection if the post is public.
	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	# CC everyone who's been addressed in the object, except ourself and the object actor's
	# follower collection
	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	{:ok,
	%{
	"id" => IDs.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/ids.ex b/lib/pleroma/web/activity_pub/ids.ex
	index bc52930a4..eab19b7fe 100644
	--- a/lib/pleroma/web/activity_pub/ids.ex
	+++ b/lib/pleroma/web/activity_pub/ids.ex
	@@ -1,25 +1,27 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.IDs do
	alias Ecto.UUID
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers, as: Routes

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Routes.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Endpoint.url()}/#{type}/#{UUID.generate()}"
	end
	+
	+ def as_local_public, do: Endpoint.url() <> "/#Public"
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex b/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	index 1eb3960d7..62767fced 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	@@ -1,107 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.IDs
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	require Pleroma.Constants

	@primary_key false

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:type, :string)
	field(:object, ObjectValidators.ObjectID)
	field(:actor, ObjectValidators.ObjectID)
	field(:context, :string, autogenerate: {IDs, :generate_context_id, []})
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:published, ObjectValidators.DateTime)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	\|> fix_after_cast()
	end

	def fix_after_cast(cng) do
	cng
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Announce"])
	\|> validate_required([:id, :type, :object, :actor, :to, :cc])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_existing_announce()
	\|> validate_announcable()
	end

	def validate_announcable(cng) do
	with actor when is_binary(actor) <- get_field(cng, :actor),
	object when is_binary(object) <- get_field(cng, :object),
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	%Object{} = object <- Object.get_cached_by_ap_id(object),
	false <- Visibility.is_public?(object) do
	same_actor = object.data["actor"] == actor.ap_id
	recipients = get_field(cng, :to) ++ get_field(cng, :cc)
	- local_public = Pleroma.Constants.as_local_public()
	+ local_public = IDs.as_local_public()

	is_public =
	Enum.member?(recipients, Pleroma.Constants.as_public()) or
	Enum.member?(recipients, local_public)

	cond do
	same_actor && is_public ->
	cng
	\|> add_error(:actor, "can not announce this object publicly")

	!same_actor ->
	cng
	\|> add_error(:actor, "can not announce this object")

	true ->
	cng
	end
	else
	_ -> cng
	end
	end

	def validate_existing_announce(cng) do
	actor = get_field(cng, :actor)
	object = get_field(cng, :object)

	if actor && object && Utils.get_existing_announce(actor, %{data: %{"id" => object}}) do
	cng
	\|> add_error(:actor, "already announced this object")
	\|> add_error(:object, "already announced by this actor")
	else
	cng
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/visibility.ex b/lib/pleroma/web/activity_pub/visibility.ex
	index 00234c0b0..fbbaf6f39 100644
	--- a/lib/pleroma/web/activity_pub/visibility.ex
	+++ b/lib/pleroma/web/activity_pub/visibility.ex
	@@ -1,150 +1,151 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Visibility do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.IDs
	alias Pleroma.Web.ActivityPub.Utils

	require Pleroma.Constants

	@spec is_public?(Object.t() \| Activity.t() \| map()) :: boolean()
	def is_public?(%Object{data: %{"type" => "Tombstone"}}), do: false
	def is_public?(%Object{data: data}), do: is_public?(data)
	def is_public?(%Activity{data: %{"type" => "Move"}}), do: true
	def is_public?(%Activity{data: data}), do: is_public?(data)
	def is_public?(%{"directMessage" => true}), do: false

	def is_public?(data) do
	Utils.label_in_message?(Pleroma.Constants.as_public(), data) or
	- Utils.label_in_message?(Pleroma.Constants.as_local_public(), data)
	+ Utils.label_in_message?(IDs.as_local_public(), data)
	end

	def is_local_public?(%Object{data: data}), do: is_local_public?(data)
	def is_local_public?(%Activity{data: data}), do: is_local_public?(data)

	def is_local_public?(data) do
	- Utils.label_in_message?(Pleroma.Constants.as_local_public(), data) and
	+ Utils.label_in_message?(IDs.as_local_public(), data) and
	not Utils.label_in_message?(Pleroma.Constants.as_public(), data)
	end

	def is_private?(activity) do
	with false <- is_public?(activity),
	%User{follower_address: follower_address} <-
	User.get_cached_by_ap_id(activity.data["actor"]) do
	follower_address in activity.data["to"]
	else
	_ -> false
	end
	end

	def is_announceable?(activity, user, public \\ true) do
	is_public?(activity) \|\|
	(!public && is_private?(activity) && activity.data["actor"] == user.ap_id)
	end

	def is_direct?(%Activity{data: %{"directMessage" => true}}), do: true
	def is_direct?(%Object{data: %{"directMessage" => true}}), do: true

	def is_direct?(activity) do
	!is_public?(activity) && !is_private?(activity)
	end

	def is_list?(%{data: %{"listMessage" => _}}), do: true
	def is_list?(_), do: false

	@spec visible_for_user?(Object.t() \| Activity.t() \| nil, User.t() \| nil) :: boolean()
	def visible_for_user?(%Activity{actor: ap_id}, %User{ap_id: ap_id}), do: true
	def visible_for_user?(%Object{data: %{"actor" => ap_id}}, %User{ap_id: ap_id}), do: true
	def visible_for_user?(nil, _), do: false
	def visible_for_user?(%Activity{data: %{"listMessage" => _}}, nil), do: false

	def visible_for_user?(
	%Activity{data: %{"listMessage" => list_ap_id}} = activity,
	%User{} = user
	) do
	user.ap_id in activity.data["to"] \|\|
	list_ap_id
	\|> Pleroma.List.get_by_ap_id()
	\|> Pleroma.List.member?(user)
	end

	def visible_for_user?(%{__struct__: module} = message, nil)
	when module in [Activity, Object] do
	if restrict_unauthenticated_access?(message),
	do: false,
	else: is_public?(message) and not is_local_public?(message)
	end

	def visible_for_user?(%{__struct__: module} = message, user)
	when module in [Activity, Object] do
	x = [user.ap_id \| User.following(user)]
	y = [message.data["actor"]] ++ message.data["to"] ++ (message.data["cc"] \|\| [])
	is_public?(message) \|\| Enum.any?(x, &(&1 in y))
	end

	def entire_thread_visible_for_user?(%Activity{} = activity, %User{} = user) do
	{:ok, %{rows: [[result]]}} =
	Ecto.Adapters.SQL.query(Repo, "SELECT thread_visibility($1, $2)", [
	user.ap_id,
	activity.data["id"]
	])

	result
	end

	def restrict_unauthenticated_access?(%Activity{local: local}) do
	restrict_unauthenticated_access_to_activity?(local)
	end

	def restrict_unauthenticated_access?(%Object{} = object) do
	object
	\|> Object.local?()
	\|> restrict_unauthenticated_access_to_activity?()
	end

	def restrict_unauthenticated_access?(%User{} = user) do
	User.visible_for(user, _reading_user = nil)
	end

	defp restrict_unauthenticated_access_to_activity?(local?) when is_boolean(local?) do
	cfg_key = if local?, do: :local, else: :remote

	Pleroma.Config.restrict_unauthenticated_access?(:activities, cfg_key)
	end

	def get_visibility(object) do
	to = object.data["to"] \|\| []
	cc = object.data["cc"] \|\| []

	cond do
	Pleroma.Constants.as_public() in to ->
	"public"

	Pleroma.Constants.as_public() in cc ->
	"unlisted"

	- Pleroma.Constants.as_local_public() in to ->
	+ IDs.as_local_public() in to ->
	"local"

	# this should use the sql for the object's activity
	Enum.any?(to, &String.contains?(&1, "/followers")) ->
	"private"

	object.data["directMessage"] == true ->
	"direct"

	is_binary(object.data["listMessage"]) ->
	"list"

	length(cc) > 0 ->
	"private"

	true ->
	"direct"
	end
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index a5265ce3e..3c38d9c6a 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,535 +1,535 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	import Pleroma.Web.Gettext

	alias Calendar.Strftime
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.IDs
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.Params
	alias Pleroma.Web.Plugs.AuthenticationPlug

	require Logger
	require Pleroma.Constants

	def attachments_from_ids(%{media_ids: ids, descriptions: desc}) do
	attachments_from_ids_descs(ids, desc)
	end

	def attachments_from_ids(%{media_ids: ids}) do
	attachments_from_ids_no_descs(ids)
	end

	def attachments_from_ids(_), do: []

	def attachments_from_ids_no_descs([]), do: []

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids, fn media_id ->
	case Repo.get(Object, media_id) do
	%Object{data: data} -> data
	_ -> nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	def attachments_from_ids_descs([], _), do: []

	def attachments_from_ids_descs(ids, descs_str) do
	{_, descs} = Jason.decode(descs_str)

	Enum.map(ids, fn media_id ->
	with %Object{data: data} <- Repo.get(Object, media_id) do
	Map.put(data, "name", descs[media_id])
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	@spec get_to_and_cc(ActivityDraft.t()) :: {list(String.t()), list(String.t())}

	def get_to_and_cc(%{in_reply_to_conversation: %Participation{} = participation}) do
	participation = Repo.preload(participation, :recipients)
	{Enum.map(participation.recipients, & &1.ap_id), []}
	end

	def get_to_and_cc(%{visibility: visibility} = draft) when visibility in ["public", "local"] do
	to =
	case visibility do
	"public" -> [Pleroma.Constants.as_public() \| draft.mentions]
	- "local" -> [Pleroma.Constants.as_local_public() \| draft.mentions]
	+ "local" -> [IDs.as_local_public() \| draft.mentions]
	end

	cc = [draft.user.follower_address]

	if draft.in_reply_to do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(%{visibility: "unlisted"} = draft) do
	to = [draft.user.follower_address \| draft.mentions]
	cc = [Pleroma.Constants.as_public()]

	if draft.in_reply_to do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(%{visibility: "private"} = draft) do
	{to, cc} = get_to_and_cc(struct(draft, visibility: "direct"))
	{[draft.user.follower_address \| to], cc}
	end

	def get_to_and_cc(%{visibility: "direct"} = draft) do
	# If the OP is a DM already, add the implicit actor.
	if draft.in_reply_to && Visibility.is_direct?(draft.in_reply_to) do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| draft.mentions]), []}
	else
	{draft.mentions, []}
	end
	end

	def get_to_and_cc(%{visibility: {:list, _}, mentions: mentions}), do: {mentions, []}

	def get_addressed_users(_, to) when is_list(to) do
	User.get_ap_ids_by_nicknames(to)
	end

	def get_addressed_users(mentioned_users, _), do: mentioned_users

	def maybe_add_list_data(activity_params, user, {:list, list_id}) do
	case Pleroma.List.get(list_id, user) do
	%Pleroma.List{} = list ->
	activity_params
	\|> put_in([:additional, "bcc"], [list.ap_id])
	\|> put_in([:additional, "listMessage"], list.ap_id)
	\|> put_in([:object, "listMessage"], list.ap_id)

	_ ->
	activity_params
	end
	end

	def maybe_add_list_data(activity_params, _, _), do: activity_params

	def make_poll_data(%{"poll" => %{"expires_in" => expires_in}} = data)
	when is_binary(expires_in) do
	# In some cases mastofe sends out strings instead of integers
	data
	\|> put_in(["poll", "expires_in"], String.to_integer(expires_in))
	\|> make_poll_data()
	end

	def make_poll_data(%{poll: %{options: options, expires_in: expires_in}} = data)
	when is_list(options) do
	limits = Config.get([:instance, :poll_limits])

	with :ok <- validate_poll_expiration(expires_in, limits),
	:ok <- validate_poll_options_amount(options, limits),
	:ok <- validate_poll_options_length(options, limits) do
	{option_notes, emoji} =
	Enum.map_reduce(options, %{}, fn option, emoji ->
	note = %{
	"name" => option,
	"type" => "Note",
	"replies" => %{"type" => "Collection", "totalItems" => 0}
	}

	{note, Map.merge(emoji, Pleroma.Emoji.Formatter.get_emoji_map(option))}
	end)

	end_time =
	DateTime.utc_now()
	\|> DateTime.add(expires_in)
	\|> DateTime.to_iso8601()

	key = if Params.truthy_param?(data.poll[:multiple]), do: "anyOf", else: "oneOf"
	poll = %{"type" => "Question", key => option_notes, "closed" => end_time}

	{:ok, {poll, emoji}}
	end
	end

	def make_poll_data(%{"poll" => poll}) when is_map(poll) do
	{:error, "Invalid poll"}
	end

	def make_poll_data(_data) do
	{:ok, {%{}, %{}}}
	end

	defp validate_poll_options_amount(options, %{max_options: max_options}) do
	if Enum.count(options) > max_options do
	{:error, "Poll can't contain more than #{max_options} options"}
	else
	:ok
	end
	end

	defp validate_poll_options_length(options, %{max_option_chars: max_option_chars}) do
	if Enum.any?(options, &(String.length(&1) > max_option_chars)) do
	{:error, "Poll options cannot be longer than #{max_option_chars} characters each"}
	else
	:ok
	end
	end

	defp validate_poll_expiration(expires_in, %{min_expiration: min, max_expiration: max}) do
	cond do
	expires_in > max -> {:error, "Expiration date is too far in the future"}
	expires_in < min -> {:error, "Expiration date is too soon"}
	true -> :ok
	end
	end

	def make_content_html(%ActivityDraft{} = draft) do
	attachment_links =
	draft.params
	\|> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
	\|> Params.truthy_param?()

	content_type = get_content_type(draft.params[:content_type])

	options =
	if draft.visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
	[safe_mention: true]
	else
	[]
	end

	draft.status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(draft.attachments, attachment_links)
	\|> maybe_add_nsfw_tag(draft.params)
	end

	defp get_content_type(content_type) do
	if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
	when sensitive in [true, "True", "true", "1"] do
	{text, mentions, [{"#nsfw", "nsfw"} \| tags]}
	end

	defp maybe_add_nsfw_tag(data, _), do: data

	def make_context(_, %Participation{} = participation) do
	Repo.preload(participation, :conversation).conversation.ap_id
	end

	def make_context(%Activity{data: %{"context" => context}}, _), do: context
	def make_context(_, _), do: IDs.generate_context_id()

	def maybe_add_attachments(parsed, _attachments, false = _no_links), do: parsed

	def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
	text = add_attachments(text, attachments)
	{text, mentions, tags}
	end

	def add_attachments(text, attachments) do
	attachment_text = Enum.map(attachments, &build_attachment_link/1)
	Enum.join([text \| attachment_text], "<br>")
	end

	defp build_attachment_link(%{"url" => [%{"href" => href} \| _]} = attachment) do
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
	end

	defp build_attachment_link(_), do: ""

	def format_input(text, format, options \\ [])

	@doc """
	Formatting text to plain text, BBCode, HTML, or Markdown
	"""
	def format_input(text, "text/plain", options) do
	text
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()
	end

	def format_input(text, "text/bbcode", options) do
	text
	\|> String.replace(~r/\r/, "")
	\|> Formatter.html_escape("text/plain")
	\|> BBCode.to_html()
	\|> (fn {:ok, html} -> html end).()
	\|> Formatter.linkify(options)
	end

	def format_input(text, "text/html", options) do
	text
	\|> Formatter.html_escape("text/html")
	\|> Formatter.linkify(options)
	end

	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Earmark.as_html!(%Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def make_note_data(%ActivityDraft{} = draft) do
	%{
	"type" => "Note",
	"to" => draft.to,
	"cc" => draft.cc,
	"content" => draft.content_html,
	"summary" => draft.summary,
	"sensitive" => draft.sensitive,
	"context" => draft.context,
	"attachment" => draft.attachments,
	"actor" => draft.user.ap_id,
	"tag" => Keyword.values(draft.tags) \|> Enum.uniq()
	}
	\|> add_in_reply_to(draft.in_reply_to)
	\|> Map.merge(draft.extra)
	end

	defp add_in_reply_to(object, nil), do: object

	defp add_in_reply_to(object, in_reply_to) do
	with %Object{} = in_reply_to_object <- Object.normalize(in_reply_to, fetch: false) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) when is_binary(date) do
	with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
	format_asctime(date)
	else
	_e ->
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end
	end

	def date_to_asctime(date) do
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) when is_binary(date) do
	with {:ok, date} <- NaiveDateTime.from_iso8601(date) do
	to_masto_date(date)
	else
	_ -> ""
	end
	end

	def to_masto_date(_), do: ""

	defp shortname(name) do
	with max_length when max_length > 0 <-
	Config.get([Pleroma.Upload, :filename_display_max_length], 30),
	true <- String.length(name) > max_length do
	String.slice(name, 0..max_length) <> "…"
	else
	_ -> name
	end
	end

	@spec confirm_current_password(User.t(), String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
	true <- AuthenticationPlug.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, dgettext("errors", "Invalid password.")}
	end
	end

	def maybe_notify_to_recipients(
	recipients,
	%Activity{data: %{"to" => to, "type" => _type}} = _activity
	) do
	recipients ++ to
	end

	def maybe_notify_to_recipients(recipients, _), do: recipients

	def maybe_notify_mentioned_recipients(
	recipients,
	%Activity{data: %{"to" => _to, "type" => type} = data} = activity
	)
	when type == "Create" do
	object = Object.normalize(activity, fetch: false)

	object_data =
	cond do
	not is_nil(object) ->
	object.data

	is_map(data["object"]) ->
	data["object"]

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	# Do not notify subscribers if author is making a reply
	def maybe_notify_subscribers(recipients, %Activity{
	object: %Object{data: %{"inReplyTo" => _ap_id}}
	}) do
	recipients
	end

	def maybe_notify_subscribers(
	recipients,
	%Activity{data: %{"actor" => actor, "type" => type}} = activity
	)
	when type == "Create" do
	with %User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscriber_users()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

	recipients ++ subscriber_ids
	else
	_e -> recipients
	end
	end

	def maybe_notify_subscribers(recipients, _), do: recipients

	def maybe_notify_followers(recipients, %Activity{data: %{"type" => "Move"}} = activity) do
	with %User{} = user <- User.get_cached_by_ap_id(activity.actor) do
	user
	\|> User.get_followers()
	\|> Enum.map(& &1.ap_id)
	\|> Enum.concat(recipients)
	else
	_e -> recipients
	end
	end

	def maybe_notify_followers(recipients, _), do: recipients

	def maybe_extract_mentions(%{"tag" => tag}) do
	tag
	\|> Enum.filter(fn x -> is_map(x) && x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	\|> Enum.uniq()
	end

	def maybe_extract_mentions(_), do: []

	def make_report_content_html(nil), do: {:ok, {nil, [], []}}

	def make_report_content_html(comment) do
	max_size = Config.get([:instance, :max_report_comment_size], 1000)

	if String.length(comment) <= max_size do
	{:ok, format_input(comment, "text/plain")}
	else
	{:error,
	dgettext("errors", "Comment must be up to %{max_size} characters", max_size: max_size)}
	end
	end

	def get_report_statuses(%User{ap_id: actor}, %{status_ids: status_ids})
	when is_list(status_ids) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

	def get_report_statuses(_, _), do: {:ok, nil}

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, %{id: id}} ->
	id

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context).id
	end
	end
	end

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, dgettext("errors", "No such conversation")}
	end
	end

	def validate_character_limit("" = _full_payload, [] = _attachments) do
	{:error, dgettext("errors", "Cannot post an empty status without attachments")}
	end

	def validate_character_limit(full_payload, _attachments) do
	limit = Config.get([:instance, :limit])
	length = String.length(full_payload)

	if length <= limit do
	:ok
	else
	{:error, dgettext("errors", "The status is over the character limit")}
	end
	end
	end
	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 e76c2760d..6c9c8f94f 100644
	--- a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	@@ -1,1956 +1,1957 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.IDs
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

	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)
	Config.get([: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
	})

	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 "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", "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", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "fake statuses' preview card is not cached", %{conn: conn} do
	clear_config([:rich_media, :enabled], true)

	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")}

	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)
	clear_config([:rich_media, :enabled], true)

	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

	@tag :skip
	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",
	"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",
	"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 _ -> "desu" 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" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
	"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(Pleroma.Workers.ScheduledActivityWorker, %{
	activity_id: scheduled_id
	})

	assert Repo.all(Oban.Job) == []

	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
	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

	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 "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 an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, is_admin: true)
	moderator = insert(:user, is_moderator: true)

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

	assert %{} = json_response_and_validate_schema(res_conn, 200)

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

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.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_str = to_string(activity.id)

	assert %{"id" => ^id_str, "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_str, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	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, 400) == %{"error" => "Could not pin"}
	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 400 error when activity is not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/unpin")

	assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not unpin"}
	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
	clear_config([:rich_media, :enabled], true)

	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(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(", ")
	[_, max_id] = Regex.run(~r/max_id=([^&]+)/, next)

	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

	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 = Pleroma.Constants.as_local_public()
	+ local = IDs.as_local_public()

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

	assert %Activity{id: ^id, data: %{"to" => [^local]}} = Activity.get_by_id(id)
	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
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 5:46 PM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737221
Default Alt Text: (100 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions