No OneTemporary
Actions

Authored By

Unknown

Size

44 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index 2b8add2fa..fcb0af4e8 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,490 +1,496 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.ActivityExpiration
	alias Pleroma.Conversation.Participation
	alias Pleroma.FollowingRelationship
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Formatter

	import Pleroma.Web.Gettext
	import Pleroma.Web.CommonAPI.Utils

	require Pleroma.Constants
	require Logger

	def post_chat_message(%User{} = user, %User{} = recipient, content) do
	transaction =
	Repo.transaction(fn ->
	- with {_, {:ok, chat_message_data, _meta}} <-
	+ with {_, true} <-
	+ {:content_length,
	+ String.length(content) <= Pleroma.Config.get([:instance, :chat_limit])},
	+ {_, {:ok, chat_message_data, _meta}} <-
	{:build_object,
	Builder.chat_message(
	user,
	recipient.ap_id,
	content \|> Formatter.html_escape("text/plain")
	)},
	{_, {:ok, chat_message_object}} <-
	{:create_object, Object.create(chat_message_data)},
	{_, {:ok, create_activity_data, _meta}} <-
	{:build_create_activity,
	Builder.create(user, chat_message_object.data["id"], [recipient.ap_id])},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline, Pipeline.common_pipeline(create_activity_data, local: true)} do
	{:ok, activity}
	+ else
	+ {:content_length, false} -> {:error, :content_too_long}
	+ e -> e
	end
	end)

	case transaction do
	{:ok, value} -> value
	error -> error
	end
	end

	def follow(follower, followed) do
	timeout = Pleroma.Config.get([:activitypub, :follow_handshake_timeout])

	with {:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, activity} <- ActivityPub.follow(follower, followed),
	{:ok, follower, followed} <- User.wait_and_refresh(timeout, follower, followed) do
	{:ok, follower, followed, activity}
	end
	end

	def unfollow(follower, unfollowed) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed),
	{:ok, _subscription} <- User.unsubscribe(follower, unfollowed) do
	{:ok, follower}
	end
	end

	def accept_follow_request(follower, followed) do
	with {:ok, follower} <- User.follow(follower, followed),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept),
	{:ok, _activity} <-
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	{:ok, follower}
	end
	end

	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
	{:ok, _activity} <-
	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	{:ok, follower}
	end
	end

	def delete(activity_id, user) do
	with {_, %Activity{data: %{"object" => _}} = activity} <-
	{:find_activity, Activity.get_by_id_with_object(activity_id)},
	%Object{} = object <- Object.normalize(activity),
	true <- User.superuser?(user) \|\| user.ap_id == object.data["actor"],
	{:ok, _} <- unpin(activity_id, user),
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not delete")}
	end
	end

	def repeat(id_or_ap_id, user, params \\ %{}) do
	with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)},
	object <- Object.normalize(activity),
	announce_activity <- Utils.get_existing_announce(user.ap_id, object),
	public <- public_announce?(object, params) do
	if announce_activity do
	{:ok, announce_activity, object}
	else
	ActivityPub.announce(user, object, nil, true, public)
	end
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not repeat")}
	end
	end

	def unrepeat(id_or_ap_id, user) do
	with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)} do
	object = Object.normalize(activity)
	ActivityPub.unannounce(user, object)
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unrepeat")}
	end
	end

	@spec favorite(User.t(), binary()) :: {:ok, Activity.t() \| :already_liked} \| {:error, any()}
	def favorite(%User{} = user, id) do
	case favorite_helper(user, id) do
	{:ok, _} = res ->
	res

	{:error, :not_found} = res ->
	res

	{:error, e} ->
	Logger.error("Could not favorite #{id}. Error: #{inspect(e, pretty: true)}")
	{:error, dgettext("errors", "Could not favorite")}
	end
	end

	def favorite_helper(user, id) do
	with {_, %Activity{object: object}} <- {:find_object, Activity.get_by_id_with_object(id)},
	{_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
	{:ok, activity}
	else
	{:find_object, _} ->
	{:error, :not_found}

	{:common_pipeline,
	{
	:error,
	{
	:validate_object,
	{
	:error,
	changeset
	}
	}
	}} = e ->
	if {:object, {"already liked by this actor", []}} in changeset.errors do
	{:ok, :already_liked}
	else
	{:error, e}
	end

	e ->
	{:error, e}
	end
	end

	def unfavorite(id_or_ap_id, user) do
	with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)} do
	object = Object.normalize(activity)
	ActivityPub.unlike(user, object)
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unfavorite")}
	end
	end

	def react_with_emoji(id, user, emoji) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	object <- Object.normalize(activity) do
	ActivityPub.react_with_emoji(user, object, emoji)
	else
	_ ->
	{:error, dgettext("errors", "Could not add reaction emoji")}
	end
	end

	def unreact_with_emoji(id, user, emoji) do
	with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji) do
	ActivityPub.unreact_with_emoji(user, reaction_activity.data["id"])
	else
	_ ->
	{:error, dgettext("errors", "Could not remove reaction emoji")}
	end
	end

	def vote(user, %{data: %{"type" => "Question"}} = object, choices) do
	with :ok <- validate_not_author(object, user),
	:ok <- validate_existing_votes(user, object),
	{:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
	answer_activities =
	Enum.map(choices, fn index ->
	answer_data = make_answer_data(user, object, Enum.at(options, index)["name"])

	{:ok, activity} =
	ActivityPub.create(%{
	to: answer_data["to"],
	actor: user,
	context: object.data["context"],
	object: answer_data,
	additional: %{"cc" => answer_data["cc"]}
	})

	activity
	end)

	object = Object.get_cached_by_ap_id(object.data["id"])
	{:ok, answer_activities, object}
	end
	end

	defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
	do: {:error, dgettext("errors", "Poll's author can't vote")}

	defp validate_not_author(_, _), do: :ok

	defp validate_existing_votes(%{ap_id: ap_id}, object) do
	if Utils.get_existing_votes(ap_id, object) == [] do
	:ok
	else
	{:error, dgettext("errors", "Already voted")}
	end
	end

	defp get_options_and_max_count(%{data: %{"anyOf" => any_of}}), do: {any_of, Enum.count(any_of)}
	defp get_options_and_max_count(%{data: %{"oneOf" => one_of}}), do: {one_of, 1}

	defp normalize_and_validate_choices(choices, object) do
	choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
	{options, max_count} = get_options_and_max_count(object)
	count = Enum.count(options)

	with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
	{_, true} <- {:count_check, Enum.count(choices) <= max_count} do
	{:ok, options, choices}
	else
	{:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
	{:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
	end
	end

	def public_announce?(_, %{"visibility" => visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility in ~w(public unlisted)

	def public_announce?(object, _) do
	Visibility.is_public?(object)
	end

	def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}

	def get_visibility(%{"visibility" => visibility}, in_reply_to, _)
	when visibility in ~w{public unlisted private direct},
	do: {visibility, get_replied_to_visibility(in_reply_to)}

	def get_visibility(%{"visibility" => "list:" <> list_id}, in_reply_to, _) do
	visibility = {:list, String.to_integer(list_id)}
	{visibility, get_replied_to_visibility(in_reply_to)}
	end

	def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
	visibility = get_replied_to_visibility(in_reply_to)
	{visibility, visibility}
	end

	def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}

	def get_replied_to_visibility(nil), do: nil

	def get_replied_to_visibility(activity) do
	with %Object{} = object <- Object.normalize(activity) do
	Visibility.get_visibility(object)
	end
	end

	def check_expiry_date({:ok, nil} = res), do: res

	def check_expiry_date({:ok, in_seconds}) do
	expiry = NaiveDateTime.utc_now() \|> NaiveDateTime.add(in_seconds)

	if ActivityExpiration.expires_late_enough?(expiry) do
	{:ok, expiry}
	else
	{:error, "Expiry date is too soon"}
	end
	end

	def check_expiry_date(expiry_str) do
	Ecto.Type.cast(:integer, expiry_str)
	\|> check_expiry_date()
	end

	def listen(user, %{"title" => _} = data) do
	with visibility <- data["visibility"] \|\| "public",
	{to, cc} <- get_to_and_cc(user, [], nil, visibility, nil),
	listen_data <-
	Map.take(data, ["album", "artist", "title", "length"])
	\|> Map.put("type", "Audio")
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)
	\|> Map.put("actor", user.ap_id),
	{:ok, activity} <-
	ActivityPub.listen(%{
	actor: user,
	to: to,
	object: listen_data,
	context: Utils.generate_context_id(),
	additional: %{"cc" => cc}
	}) do
	{:ok, activity}
	end
	end

	def post(user, %{"status" => _} = data) do
	with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do
	draft.changes
	\|> ActivityPub.create(draft.preview?)
	\|> maybe_create_activity_expiration(draft.expires_at)
	end
	end

	defp maybe_create_activity_expiration({:ok, activity}, %NaiveDateTime{} = expires_at) do
	with {:ok, _} <- ActivityExpiration.create(activity, expires_at) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(result, _), do: result

	def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
	with %Activity{
	actor: ^user_ap_id,
	data: %{"type" => "Create"},
	object: %Object{data: %{"type" => object_type}}
	} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	true <- object_type in ["Note", "Article", "Question"],
	true <- Visibility.is_public?(activity),
	{:ok, _user} <- User.add_pinnned_activity(user, activity) do
	{:ok, activity}
	else
	{:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
	_ -> {:error, dgettext("errors", "Could not pin")}
	end
	end

	def unpin(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	{:ok, _user} <- User.remove_pinnned_activity(user, activity) do
	{:ok, activity}
	else
	{:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
	_ -> {:error, dgettext("errors", "Could not unpin")}
	end
	end

	def add_mute(user, activity) do
	with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]) do
	{:ok, activity}
	else
	{:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
	end
	end

	def remove_mute(user, activity) do
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}
	end

	def thread_muted?(%{id: nil} = _user, _activity), do: false

	def thread_muted?(user, activity) do
	ThreadMute.exists?(user.id, activity.data["context"])
	end

	def report(user, %{"account_id" => account_id} = data) do
	with {:ok, account} <- get_reported_account(account_id),
	{:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
	{:ok, statuses} <- get_report_statuses(account, data) do
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: data["forward"] \|\| false
	})
	end
	end

	def report(_user, _params), do: {:error, dgettext("errors", "Valid `account_id` required")}

	defp get_reported_account(account_id) do
	case User.get_cached_by_id(account_id) do
	%User{} = account -> {:ok, account}
	_ -> {:error, dgettext("errors", "Account not found")}
	end
	end

	def update_report_state(activity_ids, state) when is_list(activity_ids) do
	case Utils.update_report_state(activity_ids, state) do
	:ok -> {:ok, activity_ids}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_report_state(activity_id, state) do
	with %Activity{} = activity <- Activity.get_by_id(activity_id) do
	Utils.update_report_state(activity, state)
	else
	nil -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_activity_scope(activity_id, opts \\ %{}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
	{:ok, activity} <- toggle_sensitive(activity, opts) do
	set_visibility(activity, opts)
	else
	nil -> {:error, :not_found}
	{:error, reason} -> {:error, reason}
	end
	end

	defp toggle_sensitive(activity, %{"sensitive" => sensitive}) when sensitive in ~w(true false) do
	toggle_sensitive(activity, %{"sensitive" => String.to_existing_atom(sensitive)})
	end

	defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sensitive})
	when is_boolean(sensitive) do
	new_data = Map.put(object.data, "sensitive", sensitive)

	{:ok, object} =
	object
	\|> Object.change(%{data: new_data})
	\|> Object.update_and_set_cache()

	{:ok, Map.put(activity, :object, object)}
	end

	defp toggle_sensitive(activity, _), do: {:ok, activity}

	defp set_visibility(activity, %{"visibility" => visibility}) do
	Utils.update_activity_visibility(activity, visibility)
	end

	defp set_visibility(activity, _), do: {:ok, activity}

	def hide_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.create_reblog_mute(user, target)
	end

	def show_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.delete_reblog_mute(user, target)
	end
	end
	diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
	index 1984aac8d..c17e30210 100644
	--- a/test/web/common_api/common_api_test.exs
	+++ b/test/web/common_api/common_api_test.exs
	@@ -1,721 +1,739 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	describe "posting chat messages" do
	+ setup do: clear_config([:instance, :chat_limit])
	+
	test "it posts a chat message" do
	author = insert(:user)
	recipient = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"a test message <script>alert('uuu')</script>"
	)

	assert activity.data["type"] == "Create"
	assert activity.local
	object = Object.normalize(activity)

	assert object.data["type"] == "ChatMessage"
	assert object.data["to"] == [recipient.ap_id]

	assert object.data["content"] ==
	"a test message <script>alert('uuu')</script>"

	assert Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)
	end
	+
	+ test "it reject messages over the local limit" do
	+ Pleroma.Config.put([:instance, :chat_limit], 2)
	+
	+ author = insert(:user)
	+ recipient = insert(:user)
	+
	+ {:error, message} =
	+ CommonAPI.post_chat_message(
	+ author,
	+ recipient,
	+ "123"
	+ )
	+
	+ assert message == :content_too_long
	+ end
	end

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{"status" => ".", "in_reply_to_conversation_id" => participation.id})

	assert Visibility.is_direct?(convo_reply)

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

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "@#{jafnhar.nickname} hey",
	"visibility" => "direct"
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "I don't really like @#{tridi.nickname}",
	"visibility" => "direct",
	"in_reply_to_status_id" => activity.id,
	"in_reply_to_conversation_id" => participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	"visibility" => "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})

	object = Object.normalize(activity)

	assert object.data["tag"] == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})

	assert Object.normalize(activity).data["emoji"]["firefox"]
	end

	describe "posting" do
	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	"to" => [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/html"
	})

	object = Object.normalize(activity)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/markdown"
	})

	object = Object.normalize(activity)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	"status" => "suya..",
	"visibility" => "direct",
	"in_reply_to_status_id" => activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	"status" => "suya..",
	"visibility" => visibility,
	"in_reply_to_status_id" => activity.id
	})
	end)
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

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

	assert activity.data["bcc"] == [list.ap_id]
	assert activity.recipients == [list.ap_id, user.ap_id]
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{"status" => ""})
	end

	test "it validates character limits are correctly enforced" do
	Pleroma.Config.put([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{"status" => "foobar"})

	assert {:ok, activity} = CommonAPI.post(user, %{"status" => "12345"})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)
	\|> NaiveDateTime.add(1_000_000, :second)

	assert {:ok, activity} =
	CommonAPI.post(user, %{"status" => "chai", "expires_in" => 1_000_000})

	assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id)
	assert expiration.scheduled_at == expires_at
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, reaction, _} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, reaction, _} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction, _} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

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

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{} = announce_activity, _} =
	CommonAPI.repeat(activity.id, user, %{"visibility" => "private"})

	assert Visibility.is_private?(announce_activity)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post_activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
	assert data["type"] == "Like"
	assert data["actor"] == user.ap_id
	assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{} = activity, object} = CommonAPI.repeat(activity.id, user)
	{:ok, ^activity, ^object} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
	assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
	end
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "How is fediverse today?",
	"poll" => %{"options" => ["Absolutely outstanding", "Not good"], "expires_in" => 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!", "visibility" => "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
	end

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

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, "You have already pinned the maximum number of statuses"} =
	CommonAPI.pin(activity_two.id, user)
	end

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

	user = refresh_record(user)

	assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

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

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	"account_id" => target_user.id,
	"comment" => comment,
	"status_ids" => [activity.id]
	}

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

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, activity_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert activity_id == activity.data["id"]
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel very offended!",
	"status_ids" => [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(follower, followed)

	refute User.subscribed_to?(follower, followed)
	end

	test "cancels a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	followed = insert(:user, locked: true, local: false, ap_enabled: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_three} = ActivityPub.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_three} = ActivityPub.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Am I cute?",
	"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
	})

	object = Object.normalize(activity)

	{:ok, _, object} = CommonAPI.vote(other_user, object, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(other_user, object, [1])
	end
	end

	describe "listen/2" do
	test "returns a valid activity" do
	user = insert(:user)

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

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "public"
	end

	test "respects visibility=private" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	"title" => "lain radio episode 1",
	"album" => "lain radio",
	"artist" => "lain",
	"length" => 180_000,
	"visibility" => "private"
	})

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end
	end
	diff --git a/test/web/pleroma_api/views/chat_message_view_test.exs b/test/web/pleroma_api/views/chat_message_view_test.exs
	index e690da022..ad8febee6 100644
	--- a/test/web/pleroma_api/views/chat_message_view_test.exs
	+++ b/test/web/pleroma_api/views/chat_message_view_test.exs
	@@ -1,42 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatMessageViewTest do
	use Pleroma.DataCase

	alias Pleroma.Chat
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.PleromaAPI.ChatMessageView

	import Pleroma.Factory

	test "it displays a chat message" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "kippis")

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

	object = Object.normalize(activity)

	chat_message = ChatMessageView.render("show.json", object: object, for: user, chat: chat)

	- assert chat_message[:id] == object.id
	+ assert chat_message[:id] == object.id \|> to_string()
	assert chat_message[:content] == "kippis"
	assert chat_message[:actor] == user.ap_id
	assert chat_message[:chat_id]

	{:ok, activity} = CommonAPI.post_chat_message(recipient, user, "gkgkgk")

	object = Object.normalize(activity)

	chat_message_two = ChatMessageView.render("show.json", object: object, for: user, chat: chat)

	- assert chat_message_two[:id] == object.id
	+ assert chat_message_two[:id] == object.id \|> to_string()
	assert chat_message_two[:content] == "gkgkgk"
	assert chat_message_two[:actor] == recipient.ap_id
	assert chat_message_two[:chat_id] == chat_message[:chat_id]
	end
	end
	diff --git a/test/web/pleroma_api/views/chat_view_test.exs b/test/web/pleroma_api/views/chat_view_test.exs
	index 1eb0c6241..3dca555e8 100644
	--- a/test/web/pleroma_api/views/chat_view_test.exs
	+++ b/test/web/pleroma_api/views/chat_view_test.exs
	@@ -1,29 +1,29 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-defmodule Pleroma.Web.PleromaAPI.ChatMessageViewTest do
	+defmodule Pleroma.Web.PleromaAPI.ChatViewTest do
	use Pleroma.DataCase

	alias Pleroma.Chat
	alias Pleroma.Web.PleromaAPI.ChatView
	alias Pleroma.Web.MastodonAPI.AccountView

	import Pleroma.Factory

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

	{:ok, chat} = Chat.get_or_create(user.id, recipient.ap_id)

	represented_chat = ChatView.render("show.json", chat: chat)

	assert represented_chat == %{
	id: "#{chat.id}",
	recipient: recipient.ap_id,
	recipient_account: AccountView.render("show.json", user: recipient),
	unread: 0
	}
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 1:15 AM (15 h, 13 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802117
Default Alt Text: (44 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions