No OneTemporary
Actions

Size

164 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/pipeline-application-without-website.fix b/changelog.d/pipeline-application-without-website.fix
	new file mode 100644
	index 000000000..ab1ab8e9e
	--- /dev/null
	+++ b/changelog.d/pipeline-application-without-website.fix
	@@ -0,0 +1 @@
	+Keep disclosed application metadata visible on created and retrieved statuses when the OAuth client has no website.
	diff --git a/lib/pleroma/web/api_spec/schemas/status.ex b/lib/pleroma/web/api_spec/schemas/status.ex
	index 63e9eebf0..76f25b97d 100644
	--- a/lib/pleroma/web/api_spec/schemas/status.ex
	+++ b/lib/pleroma/web/api_spec/schemas/status.ex
	@@ -1,376 +1,376 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Schemas.Status do
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.Attachment
	alias Pleroma.Web.ApiSpec.Schemas.Emoji
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.Poll
	alias Pleroma.Web.ApiSpec.Schemas.PreviewCard
	alias Pleroma.Web.ApiSpec.Schemas.Tag
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	require OpenApiSpex

	OpenApiSpex.schema(%{
	title: "Status",
	description: "Response schema for a status",
	type: :object,
	properties: %{
	account: %Schema{allOf: [Account], description: "The account that authored this status"},
	application: %Schema{
	description: "The application used to post this status",
	type: :object,
	nullable: true,
	properties: %{
	name: %Schema{type: :string},
	- website: %Schema{type: :string, format: :uri}
	+ website: %Schema{type: :string, format: :uri, nullable: true}
	}
	},
	bookmarked: %Schema{type: :boolean, description: "Have you bookmarked this status?"},
	card: %Schema{
	allOf: [PreviewCard],
	nullable: true
	},
	content: %Schema{type: :string, format: :html, description: "HTML-encoded status content"},
	text: %Schema{
	type: :string,
	description: "Original unformatted content in plain text",
	nullable: true
	},
	created_at: %Schema{
	type: :string,
	format: "date-time",
	description: "The date when this status was created"
	},
	edited_at: %Schema{
	type: :string,
	format: "date-time",
	nullable: true,
	description: "The date when this status was last edited"
	},
	emojis: %Schema{
	type: :array,
	items: Emoji,
	description: "Custom emoji to be used when rendering status content"
	},
	favourited: %Schema{type: :boolean, description: "Have you favourited this status?"},
	favourites_count: %Schema{
	type: :integer,
	description: "How many favourites this status has received"
	},
	id: FlakeID,
	in_reply_to_account_id: %Schema{
	allOf: [FlakeID],
	nullable: true,
	description: "ID of the account being replied to"
	},
	in_reply_to_id: %Schema{
	allOf: [FlakeID],
	nullable: true,
	description: "ID of the status being replied"
	},
	language: %Schema{
	type: :string,
	nullable: true,
	description: "Primary language of this status"
	},
	media_attachments: %Schema{
	type: :array,
	items: Attachment,
	description: "Media that is attached to this status"
	},
	mentions: %Schema{
	type: :array,
	description: "Mentions of users within the status content",
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{allOf: [FlakeID], description: "The account id of the mentioned user"},
	acct: %Schema{
	type: :string,
	description:
	"The webfinger acct: URI of the mentioned user. Equivalent to `username` for local users, or `username@domain` for remote users."
	},
	username: %Schema{type: :string, description: "The username of the mentioned user"},
	url: %Schema{
	type: :string,
	format: :uri,
	description: "The location of the mentioned user's profile"
	}
	}
	}
	},
	muted: %Schema{
	type: :boolean,
	description: "Have you muted notifications for this status's conversation?"
	},
	pinned: %Schema{
	type: :boolean,
	description: "Have you pinned this status? Only appears if the status is pinnable."
	},
	pleroma: %Schema{
	type: :object,
	properties: %{
	content: %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :string,
	description: "Alternate representation in the MIME type specified",
	extensions: %{"x-additionalPropertiesName": "MIME type"}
	},
	description:
	"A map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`"
	},
	context: %Schema{
	type: :string,
	description: "The thread identifier the status is associated with"
	},
	conversation_id: %Schema{
	type: :integer,
	deprecated: true,
	description:
	"The ID of the AP context the status is associated with (if any); deprecated, please use `context` instead"
	},
	direct_conversation_id: %Schema{
	type: :integer,
	nullable: true,
	description:
	"The ID of the Mastodon direct message conversation the status is associated with (if any)"
	},
	emoji_reactions: %Schema{
	type: :array,
	description:
	"A list with emoji / reaction maps. Contains no information about the reacting users, for that use the /statuses/:id/reactions endpoint.",
	items: %Schema{
	type: :object,
	properties: %{
	name: %Schema{type: :string},
	count: %Schema{type: :integer},
	me: %Schema{type: :boolean}
	}
	}
	},
	expires_at: %Schema{
	type: :string,
	format: "date-time",
	nullable: true,
	description:
	"A datetime (ISO 8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire"
	},
	in_reply_to_account_acct: %Schema{
	type: :string,
	nullable: true,
	description: "The `acct` property of User entity for replied user (if any)"
	},
	quote: %Schema{
	allOf: [%OpenApiSpex.Reference{"$ref": "#/components/schemas/Status"}],
	nullable: true,
	description: "Quoted status (if any)"
	},
	quote_id: %Schema{
	nullable: true,
	allOf: [FlakeID],
	description: "ID of the status being quoted, if any"
	},
	quote_url: %Schema{
	type: :string,
	format: :uri,
	nullable: true,
	description: "URL of the quoted status"
	},
	quote_visible: %Schema{
	type: :boolean,
	description: "`true` if the quoted post is visible to the user"
	},
	quotes_count: %Schema{
	type: :integer,
	deprecated: true,
	description:
	"How many statuses quoted this status. Deprecated, use `quotes_count` from parent object instead."
	},
	local: %Schema{
	type: :boolean,
	description: "`true` if the post was made on the local instance"
	},
	spoiler_text: %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :string,
	description: "Alternate representation in the MIME type specified",
	extensions: %{"x-additionalPropertiesName": "MIME type"}
	},
	description:
	"A map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`."
	},
	thread_muted: %Schema{
	type: :boolean,
	description: "`true` if the thread the post belongs to is muted"
	},
	parent_visible: %Schema{
	type: :boolean,
	description: "`true` if the parent post is visible to the user"
	},
	pinned_at: %Schema{
	type: :string,
	format: "date-time",
	nullable: true,
	description:
	"A datetime (ISO 8601) that states when the post was pinned or `null` if the post is not pinned"
	},
	list_id: %Schema{
	type: :integer,
	nullable: true,
	description:
	"The ID of the list the post is addressed to (if any, only returned to author)"
	}
	}
	},
	poll: %Schema{allOf: [Poll], nullable: true, description: "The poll attached to the status"},
	quotes_count: %Schema{
	type: :integer,
	description: "How many statuses quoted this status."
	},
	reblog: %Schema{
	allOf: [%OpenApiSpex.Reference{"$ref": "#/components/schemas/Status"}],
	nullable: true,
	description: "The status being reblogged"
	},
	reblogged: %Schema{type: :boolean, description: "Have you boosted this status?"},
	reblogs_count: %Schema{
	type: :integer,
	description: "How many boosts this status has received"
	},
	replies_count: %Schema{
	type: :integer,
	description: "How many replies this status has received"
	},
	sensitive: %Schema{
	type: :boolean,
	description: "Is this status marked as sensitive content?"
	},
	spoiler_text: %Schema{
	type: :string,
	description:
	"Subject or summary line, below which status content is collapsed until expanded"
	},
	tags: %Schema{type: :array, items: Tag},
	uri: %Schema{
	type: :string,
	format: :uri,
	description: "URI of the status used for federation"
	},
	url: %Schema{
	type: :string,
	nullable: true,
	format: :uri,
	description: "A link to the status's HTML representation"
	},
	visibility: %Schema{
	allOf: [VisibilityScope],
	description: "Visibility of this status"
	}
	},
	example: %{
	"account" => %{
	"acct" => "nick6",
	"avatar" => "http://localhost:4001/images/avi.png",
	"avatar_static" => "http://localhost:4001/images/avi.png",
	"bot" => false,
	"created_at" => "2020-04-07T19:48:51.000Z",
	"display_name" => "Test テスト User 6",
	"emojis" => [],
	"fields" => [],
	"followers_count" => 1,
	"following_count" => 0,
	"header" => "http://localhost:4001/images/banner.png",
	"header_static" => "http://localhost:4001/images/banner.png",
	"id" => "9toJCsKN7SmSf3aj5c",
	"is_locked" => false,
	"note" => "Tester Number 6",
	"pleroma" => %{
	"background_image" => nil,
	"is_confirmed" => true,
	"hide_favorites" => true,
	"hide_followers" => false,
	"hide_followers_count" => false,
	"hide_follows" => false,
	"hide_follows_count" => false,
	"is_admin" => false,
	"is_moderator" => false,
	"relationship" => %{
	"blocked_by" => false,
	"blocking" => false,
	"domain_blocking" => false,
	"endorsed" => false,
	"followed_by" => false,
	"following" => true,
	"id" => "9toJCsKN7SmSf3aj5c",
	"muting" => false,
	"muting_notifications" => false,
	"note" => "",
	"requested" => false,
	"showing_reblogs" => true,
	"subscribing" => false,
	"notifying" => false
	},
	"skip_thread_containment" => false,
	"tags" => []
	},
	"source" => %{
	"fields" => [],
	"note" => "Tester Number 6",
	"pleroma" => %{"actor_type" => "Person", "discoverable" => false},
	"sensitive" => false
	},
	"statuses_count" => 1,
	"url" => "http://localhost:4001/users/nick6",
	"username" => "nick6"
	},
	"application" => nil,
	"bookmarked" => false,
	"card" => nil,
	"content" => "foobar",
	"created_at" => "2020-04-07T19:48:51.000Z",
	"emojis" => [],
	"favourited" => false,
	"favourites_count" => 0,
	"id" => "9toJCu5YZW7O7gfvH6",
	"in_reply_to_account_id" => nil,
	"in_reply_to_id" => nil,
	"language" => nil,
	"media_attachments" => [],
	"mentions" => [],
	"muted" => false,
	"pinned" => false,
	"pleroma" => %{
	"content" => %{"text/plain" => "foobar"},
	"context" => "http://localhost:4001/objects/8b4c0c80-6a37-4d2a-b1b9-05a19e3875aa",
	"conversation_id" => 345_972,
	"direct_conversation_id" => nil,
	"emoji_reactions" => [],
	"expires_at" => nil,
	"in_reply_to_account_acct" => nil,
	"local" => true,
	"spoiler_text" => %{"text/plain" => ""},
	"thread_muted" => false,
	"quotes_count" => 0
	},
	"poll" => nil,
	"quotes_count" => 0,
	"reblog" => nil,
	"reblogged" => false,
	"reblogs_count" => 0,
	"replies_count" => 0,
	"sensitive" => false,
	"spoiler_text" => "",
	"tags" => [],
	"uri" => "http://localhost:4001/objects/0f5dad44-0e9e-4610-b377-a2631e499190",
	"url" => "http://localhost:4001/notice/9toJCu5YZW7O7gfvH6",
	"visibility" => "private"
	}
	})
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index fdf2e99ff..8dfd6ae48 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,897 +1,897 @@
	# 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.StatusView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.EmojiReactionController
	alias Pleroma.Web.RichMedia.Card

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]

	# This is a naive way to do this, just spawning a process per activity
	# to fetch the preview. However it should be fine considering
	# pagination is restricted to 40 activities at a time
	# Force disable Websockets streaming for backfill jobs,
	# otherwise old posts can show up on timelines.
	defp fetch_rich_media_for_activities(activities, opts) do
	opts = Map.put(opts, :stream, false)

	Enum.each(activities, fn activity ->
	Card.get_by_activity(activity, opts)
	end)
	end

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_quoted_activities([]), do: %{}

	defp get_quoted_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["quoteUrl"] != "" && object.data["quoteUrl"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	# DEPRECATED This field seems to be a left-over from the StatusNet era.
	# If your application uses `pleroma.conversation_id`: this field is deprecated.
	# It is currently stubbed instead by doing a CRC32 of the context, and
	# clearing the MSB to avoid overflow exceptions with signed integers on the
	# different clients using this field (Java/Kotlin code, mostly; see Husky.)
	# This should be removed in a future version of Pleroma. Pleroma-FE currently
	# depends on this field, as well.
	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
	import Bitwise

	:erlang.crc32(context)
	\|> band(bnot(0x8000_0000))
	end

	defp get_context_id(_), do: nil

	# Check if the user reblogged this status
	defp reblogged?(activity, %User{ap_id: ap_id}) do
	with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
	Object.normalize(activity, fetch: false) do
	ap_id in announcements
	else
	_ -> false
	end
	end

	# False if the user is logged out
	defp reblogged?(_activity, _user), do: false

	def render("index.json", opts) do
	reading_user = opts[:for]

	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

	# Start prefetching rich media before doing anything else
	fetch_rich_media_for_activities(activities, opts)

	replied_to_activities = get_replied_to_activities(activities)
	quoted_activities = get_quoted_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Activity.with_preloaded_bookmark(reading_user)
	\|> Activity.with_set_thread_muted_field(reading_user)
	\|> Repo.all()

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	# Note: unresolved users are filtered out
	actors =
	(activities ++ parent_activities)
	\|> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
	\|> Enum.filter(& &1)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_activities)
	\|> Map.put(:quoted_activities, quoted_activities)
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(activities, StatusView, "show.json", opts)
	end

	def render(
	"show.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	object = Object.normalize(activity, fetch: false)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	\|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()
	end

	reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
	reblogged = render("show.json", reblog_rendering_opts)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(reblogged_parent_activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: false,
	pinned: pinned?,
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: build_application(object.data["generator"]),
	language: get_language(object),
	emojis: [],
	pleroma: %{
	local: activity.local,
	pinned_at: pinned_at,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(object.data["actor"])
	user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	hashtags = Object.hashtags(object)
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	tags = Object.tags(object)

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	\|> Enum.map(fn
	Pleroma.Constants.as_public() -> nil
	^user_follower_address -> nil
	ap_id -> User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	client_posted_this_activity = opts[:for] && user.id == opts[:for].id

	expires_at =
	with true <- client_posted_this_activity,
	%Oban.Job{scheduled_at: scheduled_at} <-
	Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
	scheduled_at
	else
	_ -> nil
	end

	thread_muted? =
	cond do
	is_nil(opts[:for]) -> false
	is_boolean(activity.thread_muted?) -> activity.thread_muted?
	true -> CommonAPI.thread_muted?(activity, opts[:for])
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	edited_at =
	with %{"updated" => updated} <- object.data,
	date <- Utils.to_masto_date(updated),
	true <- date != "" do
	date
	else
	_ ->
	nil
	end

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])

	history_len =
	1 +
	(Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> length())

	# See render("history.json", ...) for more details
	# Here the implicit index of the current content is 0
	chrono_order = history_len - 1

	quote_activity = get_quote(activity, opts)

	quote_id =
	case quote_activity do
	%Activity{id: id} -> id
	_ -> nil
	end

	quote_post =
	if visible_for_user?(quote_activity, opts[:for]) and opts[:show_quote] != false do
	quote_rendering_opts = Map.merge(opts, %{activity: quote_activity, show_quote: false})
	render("show.json", quote_rendering_opts)
	else
	nil
	end

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	content_plaintext =
	content
	\|> Activity.HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	# Force disable Websockets streaming for backfill jobs which the below call will create,
	# otherwise old posts can show up on timelines.
	card =
	case Card.get_by_activity(activity, Map.put(opts, :stream, false)) do
	%Card{} = result -> render("card.json", result)
	_ -> nil
	end

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	direct_conversation_id =
	with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
	{_, true} <- {:include_id, opts[:with_direct_conversation_id]},
	{_, %User{} = for_user} <- {:for_user, opts[:for]} do
	Activity.direct_conversation_id(activity, for_user)
	else
	{:direct_conversation_id, participation_id} when is_integer(participation_id) ->
	participation_id

	_e ->
	nil
	end

	emoji_reactions =
	object
	\|> Object.get_emoji_reactions()
	\|> EmojiReactionController.filter_allowed_users(
	opts[:for],
	Map.get(opts, :with_muted, false)
	)
	\|> Stream.map(fn {emoji, users, url} ->
	build_emoji_map(emoji, users, url, opts[:for])
	end)
	\|> Enum.to_list()

	# Status muted state (would do 1 request per status unless user mutes are preloaded)
	muted =
	thread_muted? \|\|
	UserRelationship.exists?(
	get_in(opts, [:relationships, :user_relationships]),
	:mute,
	opts[:for],
	user,
	fn for_user, user -> User.mutes?(for_user, user) end
	)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	text: opts[:with_source] && get_source_text(object.data["source"]),
	created_at: created_at,
	edited_at: edited_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: muted,
	pinned: pinned?,
	sensitive: sensitive,
	spoiler_text: summary,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render(PollView, "show.json", object: object, for: opts[:for]),
	mentions: mentions,
	tags: build_tags(tags),
	application: build_application(object.data["generator"]),
	language: get_language(object),
	emojis: build_emojis(object.data["emoji"]),
	quotes_count: object.data["quotesCount"] \|\| 0,
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	context: object.data["context"],
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	quote: quote_post,
	quote_id: quote_id,
	quote_url: object.data["quoteUrl"],
	quote_visible: visible_for_user?(quote_activity, opts[:for]),
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary},
	expires_at: expires_at,
	direct_conversation_id: direct_conversation_id,
	thread_muted: thread_muted?,
	emoji_reactions: emoji_reactions,
	parent_visible: visible_for_user?(reply_to, opts[:for]),
	pinned_at: pinned_at,
	quotes_count: object.data["quotesCount"] \|\| 0,
	bookmark_folder: bookmark_folder,
	list_id: get_list_id(object, client_posted_this_activity)
	}
	}
	end

	def render("show.json", _) do
	nil
	end

	def render("history.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	hashtags = Object.hashtags(object)

	user = CommonAPI.get_user(activity.data["actor"])

	past_history =
	Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> Enum.map(&Map.put(&1, "id", object.data["id"]))
	\|> Enum.map(&%Object{data: &1, id: object.id})

	history =
	[object \| past_history]
	# Mastodon expects the original to be at the first
	\|> Enum.reverse()
	\|> Enum.with_index()
	\|> Enum.map(fn {object, chrono_order} ->
	%{
	# The history is prepended every time there is a new edit.
	# In chrono_order, the oldest item is always at 0, and so on.
	# The chrono_order is an invariant kept between edits.
	chrono_order: chrono_order,
	object: object
	}
	end)

	individual_opts =
	opts
	\|> Map.put(:as, :item)
	\|> Map.put(:user, user)
	\|> Map.put(:hashtags, hashtags)

	render_many(history, StatusView, "history_item.json", individual_opts)
	end

	def render(
	"history_item.json",
	%{
	activity: activity,
	user: user,
	item: %{object: object, chrono_order: chrono_order},
	hashtags: hashtags
	} = opts
	) do
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["updated"] \|\| object.data["published"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	%{
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	content: content_html,
	sensitive: sensitive,
	spoiler_text: summary,
	created_at: created_at,
	media_attachments: attachments,
	emojis: build_emojis(object.data["emoji"]),
	poll: render(PollView, "show.json", object: object, for: opts[:for])
	}
	end

	def render("source.json", %{activity: %{data: %{"object" => _object}} = activity} = _opts) do
	object = Object.normalize(activity, fetch: false)

	%{
	id: activity.id,
	text: get_source_text(Map.get(object.data, "source", "")),
	spoiler_text: Map.get(object.data, "summary", ""),
	content_type: get_source_content_type(object.data["source"])
	}
	end

	def render("card.json", %Card{fields: rich_media}) do
	page_url_data = URI.parse(rich_media["url"])

	page_url = page_url_data \|> to_string

	image_url = proxied_url(rich_media["image"], page_url_data)
	audio_url = proxied_url(rich_media["audio"], page_url_data)
	video_url = proxied_url(rich_media["video"], page_url_data)

	%{
	type: card_type(rich_media["type"]),
	provider_name: rich_media["provider_name"] \|\| page_url_data.host,
	provider_url:
	rich_media["provider_url"] \|\| page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url,
	image_description: rich_media["image:alt"] \|\| "",
	title: rich_media["title"] \|\| "",
	description: rich_media["description"] \|\| "",
	language: nil,
	authors: [],
	author_name: rich_media["author_name"] \|\| "",
	author_url: rich_media["author_url"] \|\| "",
	html: rich_media["html"] \|\| "",
	width: card_dimension(rich_media["width"]),
	height: card_dimension(rich_media["height"]),
	embed_url: rich_media["embed_url"] \|\| "",
	blurhash: nil,
	published_at: nil,
	pleroma: %{
	opengraph:
	rich_media
	\|> Maps.put_if_present("image", image_url)
	\|> Maps.put_if_present("audio", audio_url)
	\|> Maps.put_if_present("video", video_url)
	}
	}
	end

	def render("card.json", _), do: nil

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href_remote = attachment_url["href"]
	href = href_remote \|> MediaProxy.url()
	href_preview = attachment_url["href"] \|> MediaProxy.preview_url()
	meta = render("attachment_meta.json", %{attachment: attachment})

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	attachment_id =
	with {_, ap_id} when is_binary(ap_id) <- {:ap_id, attachment["id"]},
	{_, %Object{data: _object_data, id: object_id}} <-
	{:object, Object.get_by_ap_id(ap_id)} do
	to_string(object_id)
	else
	_ ->
	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
	to_string(attachment["id"] \|\| hash_id)
	end

	description =
	if attachment["summary"] do
	HTML.strip_tags(attachment["summary"])
	else
	attachment["name"]
	end

	name = if attachment["summary"], do: attachment["name"]

	pleroma =
	%{mime_type: media_type}
	\|> Maps.put_if_present(:name, name)

	%{
	id: attachment_id,
	url: href,
	remote_url: href_remote,
	preview_url: href_preview,
	text_url: href,
	type: type,
	description: description,
	pleroma: pleroma,
	blurhash: attachment["blurhash"]
	}
	\|> Maps.put_if_present(:meta, meta)
	end

	def render("attachment_meta.json", %{
	attachment: %{"url" => [%{"width" => width, "height" => height} \| _]}
	})
	when is_integer(width) and is_integer(height) do
	%{
	original: %{
	width: width,
	height: height,
	aspect: width / height
	}
	}
	end

	def render("attachment_meta.json", _), do: nil

	def render("context.json", %{activity: activity, activities: activities, user: user}) do
	%{ancestors: ancestors, descendants: descendants} =
	activities
	\|> Enum.reverse()
	\|> Enum.group_by(fn %{id: id} ->
	if id < activity.id, do: :ancestors, else: :descendants
	end)
	\|> Map.put_new(:ancestors, [])
	\|> Map.put_new(:descendants, [])

	%{
	ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
	descendants: render("index.json", for: user, activities: descendants, as: :activity)
	}
	end

	def render("translation.json", %{
	content: content,
	detected_source_language: detected_source_language,
	provider: provider
	}) do
	%{content: content, detected_source_language: detected_source_language, provider: provider}
	end

	defp card_type(type) when type in ["link", "photo", "video", "rich"], do: type
	defp card_type(_), do: "link"

	defp card_dimension(value) when is_integer(value) and value >= 0, do: value

	defp card_dimension(value) when is_binary(value) do
	case Integer.parse(value) do
	{dimension, ""} when dimension >= 0 -> dimension
	_ -> 0
	end
	end

	defp card_dimension(_), do: 0

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def get_quote(activity, %{quoted_activities: quoted_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- quoted_activities[object.data["quoteUrl"]] do
	# For when a quote post is inside an Announce
	Activity.get_create_by_object_ap_id_with_object(object.data["quoteUrl"])
	end
	end

	def get_quote(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["quoteUrl"] && object.data["quoteUrl"] != "" do
	Activity.get_create_by_object_ap_id(object.data["quoteUrl"])
	else
	nil
	end
	end

	def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
	url = object.data["url"] \|\| object.data["id"]

	"<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	%{"tag" => object_tags}
	\|> Object.object_data_hashtags()
	\|> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
	if pinned_at = pinned_objects[object_id] do
	{true, Utils.to_masto_date(pinned_at)}
	else
	{false, nil}
	end
	end

	defp build_emoji_map(emoji, users, url, current_user) do
	%{
	name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
	count: length(users),
	url: MediaProxy.url(url),
	me: !!(current_user && current_user.ap_id in users),
	account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	- defp build_application(%{"type" => _type, "name" => name, "url" => url}),
	- do: %{name: name, website: url}
	+ defp build_application(%{"type" => _type, "name" => name} = application),
	+ do: %{name: name, website: application["url"]}

	defp build_application(_), do: nil

	@spec build_image_url(URI.t(), URI.t()) :: String.t()
	defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
	URI.merge(page_url_data, image_url_data) \|> to_string
	end

	defp get_source_text(%{"content" => content} = _source) do
	content
	end

	defp get_source_text(source) when is_binary(source) do
	source
	end

	defp get_source_text(_) do
	""
	end

	defp get_source_content_type(%{"mediaType" => type} = _source) do
	type
	end

	defp get_source_content_type(_source) do
	Utils.get_content_type(nil)
	end

	defp get_language(%{data: %{"language" => "und"}}), do: nil

	defp get_language(object), do: object.data["language"]

	defp proxied_url(url, page_url_data) do
	if is_binary(url) do
	build_image_url(URI.parse(url), page_url_data) \|> MediaProxy.url()
	else
	nil
	end
	end

	defp get_list_id(object, client_posted_this_activity) do
	with true <- client_posted_this_activity,
	%{data: %{"listMessage" => list_ap_id}} when is_binary(list_ap_id) <- object,
	%{id: list_id} <- Pleroma.List.get_by_ap_id(list_ap_id) do
	list_id
	else
	_ -> nil
	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 6ee79689d..7de4580f0 100644
	--- a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	@@ -1,3588 +1,3612 @@
	# 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.ActivityPub.Visibility
	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 deleted status", %{user: user, conn: conn} do
	{:ok, status} = CommonAPI.post(user, %{status: "cofe"})
	{:ok, _deleted_status} = CommonAPI.delete(status.id, user)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => status.id})
	\|> json_response_and_validate_schema(422)
	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 "replying to a post the current user can't access fails", %{user: user, conn: conn} do
	stranger = insert(:user)

	{:ok, priv_post_act} =
	CommonAPI.post(stranger, %{status: "forbidden knowledge", visibility: "private"})

	assert Visibility.visible_for_user?(priv_post_act, stranger)
	refute Visibility.visible_for_user?(priv_post_act, user)

	resp =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "@#{stranger.nickname} :peek:",
	"in_reply_to_id" => priv_post_act.id,
	"visibility" => "private"
	})
	\|> json_response_and_validate_schema(422)

	assert match?(%{"error" => _}, resp)
	end

	test "replying to own DM succeeds", %{user: user, conn: conn} do
	# this is an "edge" case for visibility: replying user is not
	# part of addressed users (but is the author)
	stranger = insert(:user)

	{:ok, %{id: dm_id} = dm_post_act} =
	CommonAPI.post(user, %{
	status: "@#{stranger.nickname} wanna lose your mind to forbidden knowledge?",
	visibility: "direct"
	})

	assert Visibility.visible_for_user?(dm_post_act, stranger)
	assert Visibility.visible_for_user?(dm_post_act, user)

	resp =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "@#{stranger.nickname} :peek:",
	"in_reply_to_id" => dm_id,
	"visibility" => "direct"
	})
	\|> json_response_and_validate_schema(200)

	assert match?(%{"in_reply_to_id" => ^dm_id}, resp)
	end

	test "replying to a non-post activity fails", %{conn: conn, user: user} do
	other_user = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
	assert Visibility.visible_for_user?(follow_activity, user)

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

	assert %{"error" => "Can only reply to posts, not \"Follow\" activities"} =
	json_response_and_validate_schema(conn, 422)
	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 "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 "discloses application metadata when its website is unset" do
	+ user = insert(:user, disclose_client: true)
	+ app = insert(:oauth_app, website: nil)
	+
	+ token =
	+ insert(:oauth_token, user: user, app: app, scopes: ["write:statuses", "read:statuses"])
	+
	+ %{conn: conn} = oauth_access(token.scopes, user: user, oauth_token: token)
	+ expected = %{"name" => app.client_name, "website" => nil}
	+
	+ result =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/v1/statuses", %{"status" => "cofe is my copilot"})
	+
	+ assert %{"id" => id, "application" => ^expected} =
	+ json_response_and_validate_schema(result, 200)
	+
	+ assert %{"application" => ^expected} =
	+ conn
	+ \|> get("/api/v1/statuses/#{id}")
	+ \|> json_response_and_validate_schema(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
	remote_user = insert(:user, local: false, domain: "example.com")
	announce_user = insert(:user)
	local = insert(:note_activity)
	remote = insert(:note_activity, local: false, object_local: false, user: remote_user)
	remote_note = insert(:note_activity, local: false, object_local: false)

	local_activity_remote_object =
	insert(:announce_activity, note_activity: remote_note, user: announce_user)

	{:ok,
	local: local, remote: remote, local_activity_remote_object: local_activity_remote_object}
	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)

	{:ok, %{id: local_to_local_react_id}} = CommonAPI.react_with_emoji(id1, local_user_2, "🦊")

	{:ok, %{id: local_to_remote_react_id}} =
	CommonAPI.react_with_emoji(remote_activity.id, local_user_1, "🦊")

	{:ok, %{id: remote_to_local_react_id}} = CommonAPI.react_with_emoji(id1, remote_user, "🦊")

	{:ok, %{id: remote_to_remote_react_id}} =
	CommonAPI.react_with_emoji(remote_activity.id, remote_user, "🦊")

	%{
	locals: [id1, id2],
	remote: remote_activity.id,
	local_interactions: [local_to_local_react_id, local_to_remote_react_id],
	remote_interactions: [remote_to_local_react_id, remote_to_remote_react_id],
	context: context
	}
	end

	defp extract_activity_ids_from_response(list) when is_list(list) do
	list
	\|> Enum.map(& &1["id"])
	end

	defp all_ids_included?(checked, authority) when is_list(checked) and is_list(authority) do
	set1 = MapSet.new(checked)
	set2 = MapSet.new(authority)
	MapSet.equal?(set1, set2)
	end

	defp local_interactions_to_remote do
	interacted_user = insert(:user, local: false, domain: "example.com")
	interacting_user = insert(:user)

	announced_post =
	insert(:note_activity, local: false, object_local: false, user: interacted_user)

	emoji_reacted_post =
	insert(:note_activity, local: false, object_local: false, user: interacted_user)

	favorited_post =
	insert(:note_activity, local: false, object_local: false, user: interacted_user)

	announce = insert(:announce_activity, note_activity: announced_post, user: interacting_user)

	emoji_react =
	insert(:emoji_react_activity, note_activity: emoji_reacted_post, user: interacting_user)

	{:ok, favorite} = CommonAPI.favorite(favorited_post.id, interacting_user)

	{
	:ok,
	announce: announce,
	emoji_react: emoji_react,
	favorite: favorite,
	interacted: interacted_user,
	interacter: interacting_user
	}
	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,
	local_activity_remote_object: local_activity_remote_object
	} 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"
	}

	res_conn = get(conn, "/api/v1/statuses/#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} 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)

	res_conn = get(conn, "/api/v1/statuses/#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} 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/#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} 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)

	res_conn = get(conn, "/api/v1/statuses/#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} 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"
	}

	res_conn = get(conn, "/api/v1/statuses/#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} 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)

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

	# Note: Activities of type Flag,Follow,Delete,Accept,Reject,Undo return 404
	describe "status has correct attribution when fetching as" do
	setup do: local_interactions_to_remote()

	test "Add/Remove activity", %{conn: conn, interacter: user} do
	add = insert(:add_activity, user: user)
	add_id = add.id
	remove = insert(:remove_activity, user: user)
	remove_id = remove.id
	user_id = user.id

	# Schema validation fails:
	# null value where integer expected at /pleroma/conversation_id
	result1 =
	conn
	\|> get("/api/v1/statuses/#{add_id}")
	\|> json_response(200)

	assert match?(%{"id" => ^add_id, "account" => %{"id" => ^user_id}}, result1)

	result2 =
	conn
	\|> get("/api/v1/statuses/#{remove_id}")
	\|> json_response(200)

	assert match?(%{"id" => ^remove_id, "account" => %{"id" => ^user_id}}, result2)
	end

	test "Announce activity", %{
	conn: conn,
	announce: activity,
	interacter: interacter,
	interacted: user
	} do
	announce_id = activity.id
	announced_activity = Pleroma.Activity.get_create_by_object_ap_id(activity.data["object"])
	announced_id = announced_activity.id
	interacter_ap_id = interacter.id
	user_id = user.id

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

	assert match?(
	%{
	"id" => ^announce_id,
	"account" => %{"id" => ^interacter_ap_id},
	"reblog" => %{"account" => %{"id" => ^user_id}, "id" => ^announced_id}
	},
	result
	)
	end

	test "Create activity", %{conn: conn, interacted: user} do
	note_activity = insert(:note_activity, local: false, object_local: false, user: user)
	note_activity_id = note_activity.id
	user_id = user.id

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

	assert match?(%{"id" => ^note_activity_id, "account" => %{"id" => ^user_id}}, result)
	end

	test "EmojiReact activity", %{conn: conn, emoji_react: activity, interacted: user} do
	emoji_react_id = activity.id
	user_id = user.id

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

	assert match?(%{"id" => ^emoji_react_id, "account" => %{"id" => ^user_id}}, result)
	end

	test "Like activity", %{conn: conn, favorite: activity, interacted: user} do
	like_id = activity.id
	user_id = user.id

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

	assert match?(%{"id" => ^like_id, "account" => %{"id" => ^user_id}}, result)
	end

	test "Update activity" do
	%{conn: conn, user: user} = oauth_access(["write:statuses"])
	user_id = user.id

	{:ok, activity} = CommonAPI.post(user, %{status: "This will be edited"})
	{:ok, updated_activity} = CommonAPI.update(activity, user, %{status: "edited"})

	activity_id = activity.id
	updated_activity_id = updated_activity.id

	result1 =
	conn
	\|> get("/api/v1/statuses/#{activity_id}")
	\|> json_response_and_validate_schema(200)

	# Even though we ask for the original Create activity, updated post is served
	assert match?(
	%{
	"id" => ^activity_id,
	"account" => %{"id" => ^user_id},
	"content" => "edited"
	},
	result1
	)

	# Schema validation fails:
	# null value where integer expected at /pleroma/conversation_id
	result2 =
	conn
	\|> get("/api/v1/statuses/#{updated_activity_id}")
	\|> json_response(200)

	assert match?(
	%{
	"id" => ^updated_activity_id,
	"account" => %{"id" => ^user_id},
	"content" => "edited"
	},
	result2
	)
	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 = "id[]=#{id1}&id[]=#{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

	test "get statuses by IDs falls back to ids[]" do
	%{conn: conn} = oauth_access(["read:statuses"])
	%{id: id} = insert(:note_activity)

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

	assert [%{"id" => ^id}] = json_response_and_validate_schema(conn, 200)
	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,
	local_activity_remote_object: local_activity_remote_object
	} do
	res_conn =
	get(
	conn,
	"/api/v1/statuses?id[]=#{local.id}&id[]=#{remote.id}&id[]=#{local_activity_remote_object.id}"
	)

	assert json_response_and_validate_schema(res_conn, 200) == []
	end

	test "if user is authenticated", %{
	local: local,
	remote: remote,
	local_activity_remote_object: local_activity_remote_object
	} do
	%{conn: conn} = oauth_access(["read"])

	res_conn =
	get(
	conn,
	"/api/v1/statuses?id[]=#{local.id}&id[]=#{remote.id}&id[]=#{local_activity_remote_object.id}"
	)

	assert length(json_response_and_validate_schema(res_conn, 200)) == 3
	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,
	local_activity_remote_object: local_activity_remote_object
	} do
	res_conn =
	get(
	conn,
	"/api/v1/statuses?id[]=#{local.id}&id[]=#{remote.id}&id[]=#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} do
	%{conn: conn} = oauth_access(["read"])

	res_conn =
	get(
	conn,
	"/api/v1/statuses?id[]=#{local.id}&id[]=#{remote.id}&id[]=#{local_activity_remote_object.id}"
	)

	assert length(json_response_and_validate_schema(res_conn, 200)) == 3
	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,
	local_activity_remote_object: local_activity_remote_object
	} do
	res_conn =
	get(
	conn,
	"/api/v1/statuses?id[]=#{local.id}&id[]=#{remote.id}&id[]=#{local_activity_remote_object.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,
	local_activity_remote_object: local_activity_remote_object
	} do
	%{conn: conn} = oauth_access(["read"])

	res_conn =
	get(
	conn,
	"/api/v1/statuses?id[]=#{local.id}&id[]=#{remote.id}&id[]=#{local_activity_remote_object.id}"
	)

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

	# Note: Context route on EmojiReact/Announce activities puts everything into the ancestors field
	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 unauthenticated Activity interactions", %{
	conn: conn,
	local_interactions: [local_to_local, local_to_remote],
	remote_interactions: [remote_to_local, remote_to_remote]
	} do
	res_conn = get(conn, "/api/v1/statuses/#{local_to_local}/context")

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

	res_conn = get(conn, "/api/v1/statuses/#{local_to_remote}/context")

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

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_local}/context")

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

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_remote}/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

	test "if user is authenticated Activity interactions", %{
	locals: [post_id, reply_id],
	remote: remote_reply_id,
	local_interactions: [local_to_local, local_to_remote],
	remote_interactions: [remote_to_local, remote_to_remote]
	} do
	%{conn: conn} = oauth_access(["read"])
	all_ids = [post_id, reply_id, remote_reply_id]
	res_conn = get(conn, "/api/v1/statuses/#{local_to_local}/context")

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

	ancestor_ids1 = extract_activity_ids_from_response(ancestors1)
	assert all_ids_included?(ancestor_ids1, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{local_to_remote}/context")

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

	ancestor_ids2 = extract_activity_ids_from_response(ancestors2)
	assert all_ids_included?(ancestor_ids2, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_local}/context")

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

	ancestor_ids3 = extract_activity_ids_from_response(ancestors3)
	assert all_ids_included?(ancestor_ids3, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_remote}/context")

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

	ancestor_ids4 = extract_activity_ids_from_response(ancestors4)
	assert all_ids_included?(ancestor_ids4, all_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 unauthenticated Activity interactions", %{
	conn: conn,
	remote: remote_reply_id,
	local_interactions: [local_to_local, local_to_remote],
	remote_interactions: [remote_to_local, remote_to_remote]
	} do
	res_conn = get(conn, "/api/v1/statuses/#{local_to_local}/context")

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

	ancestor_ids1 = extract_activity_ids_from_response(ancestors1)
	assert all_ids_included?(ancestor_ids1, [remote_reply_id])

	res_conn = get(conn, "/api/v1/statuses/#{local_to_remote}/context")

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

	ancestor_ids2 = extract_activity_ids_from_response(ancestors2)
	assert all_ids_included?(ancestor_ids2, [remote_reply_id])

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_local}/context")

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

	ancestor_ids3 = extract_activity_ids_from_response(ancestors3)
	assert all_ids_included?(ancestor_ids3, [remote_reply_id])

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_remote}/context")

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

	ancestor_ids4 = extract_activity_ids_from_response(ancestors4)
	assert all_ids_included?(ancestor_ids4, [remote_reply_id])
	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

	test "if user is authenticated Activity interactions", %{
	locals: [post_id, reply_id],
	remote: remote_reply_id,
	local_interactions: [local_to_local, local_to_remote],
	remote_interactions: [remote_to_local, remote_to_remote]
	} do
	%{conn: conn} = oauth_access(["read"])
	all_ids = [post_id, reply_id, remote_reply_id]
	res_conn = get(conn, "/api/v1/statuses/#{local_to_local}/context")

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

	ancestor_ids1 = extract_activity_ids_from_response(ancestors1)
	assert all_ids_included?(ancestor_ids1, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{local_to_remote}/context")

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

	ancestor_ids2 = extract_activity_ids_from_response(ancestors2)
	assert all_ids_included?(ancestor_ids2, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_local}/context")

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

	ancestor_ids3 = extract_activity_ids_from_response(ancestors3)
	assert all_ids_included?(ancestor_ids3, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_remote}/context")

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

	ancestor_ids4 = extract_activity_ids_from_response(ancestors4)
	assert all_ids_included?(ancestor_ids4, all_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 unauthenticated Activity interactions", %{
	conn: conn,
	locals: [post_id, reply_id],
	local_interactions: [local_to_local, local_to_remote],
	remote_interactions: [remote_to_local, remote_to_remote]
	} do
	res_conn = get(conn, "/api/v1/statuses/#{local_to_local}/context")
	all_ids = [post_id, reply_id]

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

	ancestor_ids1 = extract_activity_ids_from_response(ancestors1)
	assert all_ids_included?(ancestor_ids1, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{local_to_remote}/context")

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

	ancestor_ids2 = extract_activity_ids_from_response(ancestors2)
	assert all_ids_included?(ancestor_ids2, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_local}/context")

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

	ancestor_ids3 = extract_activity_ids_from_response(ancestors3)
	assert all_ids_included?(ancestor_ids3, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_remote}/context")

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

	ancestor_ids4 = extract_activity_ids_from_response(ancestors4)
	assert all_ids_included?(ancestor_ids4, all_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

	test "if user is authenticated Activity interactions", %{
	locals: [post_id, reply_id],
	remote: remote_reply_id,
	local_interactions: [local_to_local, local_to_remote],
	remote_interactions: [remote_to_local, remote_to_remote]
	} do
	%{conn: conn} = oauth_access(["read"])
	all_ids = [post_id, reply_id, remote_reply_id]
	res_conn = get(conn, "/api/v1/statuses/#{local_to_local}/context")

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

	ancestor_ids1 = extract_activity_ids_from_response(ancestors1)
	assert all_ids_included?(ancestor_ids1, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{local_to_remote}/context")

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

	ancestor_ids2 = extract_activity_ids_from_response(ancestors2)
	assert all_ids_included?(ancestor_ids2, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_local}/context")

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

	ancestor_ids3 = extract_activity_ids_from_response(ancestors3)
	assert all_ids_included?(ancestor_ids3, all_ids)

	res_conn = get(conn, "/api/v1/statuses/#{remote_to_remote}/context")

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

	ancestor_ids4 = extract_activity_ids_from_response(ancestors4)
	assert all_ids_included?(ancestor_ids4, all_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(activity.id, user2)
	{: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

	test "cannot reblog private status of others (even if visible)", %{conn: conn, user: user} do
	followed = insert(:user, local: true)

	{:ok, _, _, %{data: %{"state" => "accept"}}} = CommonAPI.follow(followed, user)

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

	assert Visibility.visible_for_user?(activity, user)

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

	assert match?(%{"error" => _}, resp)
	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

	test "can't unreblog someone else's reblog", %{user: user, conn: conn} do
	activity = insert(:note_activity)
	other_user = insert(:user)

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

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

	assert match?(%{"error" => _}, resp1)

	# unreblog by reblog ID (reblog IDs are accepted by some APIs;
	# ensure it fails here one way or another)
	resp2 =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write", "read"]))
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{reblog_id}/unreblog")
	\|> json_response_and_validate_schema(404)

	assert match?(%{"error" => _}, resp2)
	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 "a status you cannot see fails", %{conn: conn} do
	stranger = insert(:user)

	{:ok, activity} =
	CommonAPI.post(stranger, %{status: "it can eternal lie", visibility: "private"})

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/favourite")
	\|> json_response_and_validate_schema(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(activity.id, user)

	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 "can't unfavourite post that isn't visible to user" do
	user = insert(:user)
	%{conn: conn, user: stranger} = oauth_access(["write:favourites"])
	{:ok, activity} = CommonAPI.post(user, %{status: "invisible", visibility: "private"})

	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(activity, stranger)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	end

	test "can't unfavourite post that isn't favourited", %{conn: conn} do
	activity = insert(:note_activity)

	# using base post ID
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")
	\|> json_response_and_validate_schema(400) == %{"error" => "Could not unfavorite"}
	end

	test "can't unfavourite other user's favs", %{conn: conn} do
	activity = insert(:note_activity)

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

	# using base post ID
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")
	\|> json_response_and_validate_schema(400) == %{"error" => "Could not unfavorite"}
	end

	test "can't unfavourite other user's favs using their activity", %{conn: conn} do
	activity = insert(:note_activity)

	other = insert(:user)
	{:ok, fav_activity} = CommonAPI.favorite(activity.id, other)
	# some APIs (used to) take IDs of any activity type, make sure this fails one way or another
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{fav_activity.id}/unfavourite")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	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

	test "can't favourite post that isn't visible to user" do
	user = insert(:user)
	%{conn: conn, user: stranger} = oauth_access(["write:favourites"])
	{:ok, activity} = CommonAPI.post(user, %{status: "invisible", visibility: "private"})

	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(activity, stranger)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	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 422 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: returns 404 error when activity not visible to user", %{user: user} do
	%{conn: conn, user: stranger} = oauth_access(["write:accounts"])
	{:ok, activity} = CommonAPI.post(user, %{status: "invisible", visibility: "private"})

	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(activity, stranger)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	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 "/unpin: returns 404 error when activity not visible to user", %{user: user} do
	%{conn: conn, user: stranger} = oauth_access(["write:accounts"])
	{:ok, activity} = CommonAPI.post(user, %{status: "yumi", visibility: "private"})

	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(activity, stranger)

	assert conn
	\|> assign(:user, stranger)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	end

	test "/unpin: returns 422 error when activity not owned by user", %{activity: activity} do
	%{conn: conn, user: user} = oauth_access(["write:accounts"])

	assert Pleroma.Web.ActivityPub.Visibility.visible_for_user?(activity, user)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response_and_validate_schema(422) == %{
	"error" => "Someone else's status cannot be unpinned"
	}
	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)
	Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)

	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"})
	ObanHelpers.perform_all()

	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."
	}
	},
	"author_name" => "",
	"author_url" => "",
	"authors" => [],
	"blurhash" => nil,
	"embed_url" => "",
	"height" => 0,
	"html" => "",
	"image_description" => "",
	"language" => nil,
	"published_at" => nil,
	"width" => 0
	}

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

	assert response["card"] == 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}")
	\|> json_response_and_validate_schema(200)

	assert response_two["card"] == 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"})
	ObanHelpers.perform_all()

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

	assert response["card"] == %{
	"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"
	}
	},
	"author_name" => "",
	"author_url" => "",
	"authors" => [],
	"blurhash" => nil,
	"embed_url" => "",
	"height" => 0,
	"html" => "",
	"image_description" => "",
	"language" => nil,
	"published_at" => nil,
	"width" => 0
	}
	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

	test "cannot bookmark invisible post" do
	user = insert(:user)
	%{conn: conn, user: stranger} = oauth_access(["write:bookmarks"])
	{:ok, activity} = CommonAPI.post(user, %{status: "mocha", visibility: "private"})

	refute Pleroma.Web.ActivityPub.Visibility.visible_for_user?(activity, stranger)

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

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

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

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

	test "bookmark folders" do
	%{conn: conn, user: user} = oauth_access(["write:bookmarks", "read:bookmarks"])

	{:ok, folder} = Pleroma.BookmarkFolder.create(user.id, "folder")
	author = insert(:user)

	folder_bookmarks_uri = "/api/v1/bookmarks?folder_id=#{folder.id}"

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

	# Add bookmark with a folder
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark", %{folder_id: folder.id})

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

	assert json_response_and_validate_schema(response, 200)["pleroma"]["bookmark_folder"] ==
	folder.id

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

	assert json_response_and_validate_schema(response, 200)["bookmarked"] == true
	assert json_response_and_validate_schema(response, 200)["pleroma"]["bookmark_folder"] == nil

	bookmarks =
	get(conn, folder_bookmarks_uri)
	\|> json_response_and_validate_schema(200)

	assert length(bookmarks) == 1

	# Update folder for existing bookmark
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark", %{folder_id: folder.id})

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

	assert json_response_and_validate_schema(response, 200)["pleroma"]["bookmark_folder"] ==
	folder.id

	bookmarks =
	get(conn, folder_bookmarks_uri)
	\|> json_response_and_validate_schema(200)

	assert length(bookmarks) == 2
	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(activity, user)

	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(activity, user)

	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

	test "cannot mute not visible conversation", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "Invisible!", visibility: "private"})
	%{conn: conn} = oauth_access(["write:mutes"])

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response_and_validate_schema(404) == %{
	"error" => "Record not found"
	}
	end

	test "cannot unmute not visible conversation", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "Invisible!", visibility: "private"})
	%{conn: conn} = oauth_access(["write:mutes"])

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response_and_validate_schema(404) == %{
	"error" => "Record not found"
	}
	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 ordered from newest to oldest", %{
	conn: conn,
	activity: activity
	} do
	[other_user_1, other_user_2] = insert_pair(:user)
	[other_user_3, other_user_4] = insert_pair(:user)

	{:ok, _} = CommonAPI.favorite(activity.id, other_user_1)
	{:ok, _} = CommonAPI.favorite(activity.id, other_user_3)
	{:ok, _} = CommonAPI.favorite(activity.id, other_user_2)
	{:ok, _} = CommonAPI.favorite(activity.id, other_user_4)

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

	[%{"id" => id1}, %{"id" => id2}, %{"id" => id3}, %{"id" => id4}] = response

	assert id1 == other_user_4.id
	assert id2 == other_user_2.id
	assert id3 == other_user_3.id
	assert id4 == other_user_1.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(activity.id, other_user)

	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(activity.id, other_user)

	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(activity.id, other_user)

	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 "fails when base post not visible to current user", %{user: user} do
	other_user = insert(:user, local: true)
	%{conn: conn} = oauth_access(["read:accounts"])

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "craving tea and mochi rn",
	visibility: "private"
	})

	assert conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	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(activity.id, other_user)

	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

	test "does fail when requesting for a non-visible status", %{user: user} do
	other_user = insert(:user, local: true)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "deep below it sleeps and mustn't wake",
	visibility: "private"
	})

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

	assert match?(%{"error" => _}, 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 "context doesn't leak priv posts" do
	%{user: user, conn: conn} = oauth_access(["read:statuses"])
	stranger = insert(:user)

	{:ok, %{id: id1}} = CommonAPI.post(stranger, %{status: "1", visibility: "public"})

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

	{:ok, %{id: _id_boo} = act_boo} =
	CommonAPI.post(stranger, %{status: "boo", visibility: "private", in_reply_to_status_id: id1})

	refute Visibility.visible_for_user?(act_boo, user)

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

	assert match?(
	%{
	"ancestors" => [],
	"descendants" => [%{"id" => ^id2}]
	},
	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(third_post.id, user)
	{:ok, _second_favorite} = CommonAPI.favorite(first_post.id, user)
	{:ok, third_favorite} = CommonAPI.favorite(second_post.id, user)

	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(activity.id, user)

	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(second_activity.id, user)

	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(
	DateTime.truncate(expires_at, :second),
	DateTime.truncate(a_expires_at, :second)
	) == 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/?id[]=#{activity.id}")
	\|> json_response_and_validate_schema(200)

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

	result =
	conn
	\|> get("/api/v1/statuses/?id[]=#{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

	describe "translating statuses" do
	setup do: clear_config([Pleroma.Language.Translation, :provider], TranslationMock)

	test "it translates a status to user language" do
	user = insert(:user, language: "fr")
	%{conn: conn} = oauth_access(["read:statuses"], user: user)
	another_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(another_user, %{
	status: "Cześć!",
	visibility: "public",
	language: "pl"
	})

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

	assert response == %{
	"content" => "!ćśezC",
	"detected_source_language" => "pl",
	"provider" => "TranslationMock"
	}
	end

	test "it returns an error if no target language provided" do
	%{conn: conn} = oauth_access(["read:statuses"])
	another_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(another_user, %{
	status: "Cześć!",
	language: "pl"
	})

	assert conn
	\|> post("/api/v1/statuses/#{activity.id}/translate")
	\|> json_response_and_validate_schema(400)
	end

	test "it doesn't translate non-public statuses" do
	%{conn: conn, user: user} = oauth_access(["read:statuses"])

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Cześć!",
	visibility: "private",
	language: "pl"
	})

	assert conn
	\|> post("/api/v1/statuses/#{activity.id}/translate")
	\|> json_response_and_validate_schema(404)
	end
	end

	describe "getting quotes of a specified post" do
	setup do
	[current_user, user] = insert_pair(:user)
	%{user: current_user, conn: conn} = oauth_access(["read:statuses"], user: current_user)
	[current_user: current_user, user: user, conn: conn]
	end

	test "shows quotes of a post", %{conn: conn} do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, quote_post} = CommonAPI.post(user, %{status: "quoat", quote_id: activity.id})

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

	[status] = response

	assert length(response) == 1
	assert status["id"] == quote_post.id
	end

	test "returns 404 error when a post can't be seen", %{conn: conn} do
	activity = insert(:direct_note_activity)

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

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

	test "returns 404 error when a post does not exist", %{conn: conn} do
	response =
	conn
	\|> get("/api/v1/statuses/idontexist/quotes")

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

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 12:33 PM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1769483
Default Alt Text: (164 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions