No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/chat.ex b/lib/pleroma/chat.ex
	index 4c92a58c7..211b872f9 100644
	--- a/lib/pleroma/chat.ex
	+++ b/lib/pleroma/chat.ex
	@@ -1,105 +1,110 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Chat do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User

	@moduledoc """
	Chat keeps a reference to ChatMessage conversations between a user and an recipient. The recipient can be a user (for now) or a group (not implemented yet).

	It is a helper only, to make it easy to display a list of chats with other people, ordered by last bump. The actual messages are retrieved by querying the recipients of the ChatMessages.
	"""

	schema "chats" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	field(:recipient, :string)
	field(:unread, :integer, default: 0, read_after_writes: true)

	timestamps()
	end

	def last_message_for_chat(chat) do
	messages_for_chat_query(chat)
	\|> order_by(desc: :id)
	\|> limit(1)
	\|> Repo.one()
	end

	def messages_for_chat_query(chat) do
	chat =
	chat
	\|> Repo.preload(:user)

	from(o in Object,
	where: fragment("?->>'type' = ?", o.data, "ChatMessage"),
	where:
	fragment(
	"""
	(?->>'actor' = ? and ?->'to' = ?)
	OR (?->>'actor' = ? and ?->'to' = ?)
	""",
	o.data,
	^chat.user.ap_id,
	o.data,
	^[chat.recipient],
	o.data,
	^chat.recipient,
	o.data,
	^[chat.user.ap_id]
	)
	)
	end

	def creation_cng(struct, params) do
	struct
	\|> cast(params, [:user_id, :recipient, :unread])
	\|> validate_change(:recipient, fn
	:recipient, recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil -> [recipient: "must be an existing user"]
	_ -> []
	end
	end)
	\|> validate_required([:user_id, :recipient])
	\|> unique_constraint(:user_id, name: :chats_user_id_recipient_index)
	end

	+ def get_by_id(id) do
	+ __MODULE__
	+ \|> Repo.get(id)
	+ end
	+
	def get(user_id, recipient) do
	__MODULE__
	\|> Repo.get_by(user_id: user_id, recipient: recipient)
	end

	def get_or_create(user_id, recipient) do
	%__MODULE__{}
	\|> creation_cng(%{user_id: user_id, recipient: recipient})
	\|> Repo.insert(
	# Need to set something, otherwise we get nothing back at all
	on_conflict: [set: [recipient: recipient]],
	returning: true,
	conflict_target: [:user_id, :recipient]
	)
	end

	def bump_or_create(user_id, recipient) do
	%__MODULE__{}
	\|> creation_cng(%{user_id: user_id, recipient: recipient, unread: 1})
	\|> Repo.insert(
	on_conflict: [set: [updated_at: NaiveDateTime.utc_now()], inc: [unread: 1]],
	conflict_target: [:user_id, :recipient]
	)
	end

	def mark_as_read(chat) do
	chat
	\|> change(%{unread: 0})
	\|> Repo.update()
	end
	end
	diff --git a/lib/pleroma/chat_message_reference.ex b/lib/pleroma/chat_message_reference.ex
	new file mode 100644
	index 000000000..e9ca3dfe8
	--- /dev/null
	+++ b/lib/pleroma/chat_message_reference.ex
	@@ -0,0 +1,80 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.ChatMessageReference do
	+ @moduledoc """
	+ A reference that builds a relation between an AP chat message that a user can see and whether it has been seen
	+ by them, or should be displayed to them. Used to build the chat view that is presented to the user.
	+ """
	+
	+ use Ecto.Schema
	+
	+ alias Pleroma.Chat
	+ alias Pleroma.Object
	+ alias Pleroma.Repo
	+
	+ import Ecto.Changeset
	+ import Ecto.Query
	+
	+ @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
	+
	+ schema "chat_message_references" do
	+ belongs_to(:object, Object)
	+ belongs_to(:chat, Chat)
	+
	+ field(:seen, :boolean, default: false)
	+
	+ timestamps()
	+ end
	+
	+ def changeset(struct, params) do
	+ struct
	+ \|> cast(params, [:object_id, :chat_id, :seen])
	+ \|> validate_required([:object_id, :chat_id, :seen])
	+ end
	+
	+ def get_by_id(id) do
	+ __MODULE__
	+ \|> Repo.get(id)
	+ \|> Repo.preload(:object)
	+ end
	+
	+ def delete(cm_ref) do
	+ cm_ref
	+ \|> Repo.delete()
	+ end
	+
	+ def delete_for_object(%{id: object_id}) do
	+ from(cr in __MODULE__,
	+ where: cr.object_id == ^object_id
	+ )
	+ \|> Repo.delete_all()
	+ end
	+
	+ def for_chat_and_object(%{id: chat_id}, %{id: object_id}) do
	+ __MODULE__
	+ \|> Repo.get_by(chat_id: chat_id, object_id: object_id)
	+ \|> Repo.preload(:object)
	+ end
	+
	+ def for_chat_query(chat) do
	+ from(cr in __MODULE__,
	+ where: cr.chat_id == ^chat.id,
	+ order_by: [desc: :id],
	+ preload: [:object]
	+ )
	+ end
	+
	+ def create(chat, object, seen) do
	+ params = %{
	+ chat_id: chat.id,
	+ object_id: object.id,
	+ seen: seen
	+ }
	+
	+ %__MODULE__{}
	+ \|> changeset(params)
	+ \|> Repo.insert()
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index a34bf6a05..cda52b00e 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,193 +1,198 @@
	defmodule Pleroma.Web.ActivityPub.SideEffects do
	@moduledoc """
	This module looks at an inserted object and executes the side effects that it
	implies. For example, a `Like` activity will increase the like count on the
	liked object, a `Follow` activity will add the user to the follower
	collection, and so on.
	"""
	alias Pleroma.Activity
	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Streamer

	def handle(object, meta \\ [])

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	def handle(%{data: %{"type" => "Like"}} = object, meta) do
	liked_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_like_to_object(object, liked_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Set up notifications
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, _object, _meta} <- handle_object_creation(meta[:object_data], meta) do
	Notification.create_notifications(activity)
	{:ok, activity, meta}
	else
	e -> Repo.rollback(e)
	end
	end

	# Tasks this handles:
	# - Add announce to object
	# - Set up notification
	# - Stream out the announce
	def handle(%{data: %{"type" => "Announce"}} = object, meta) do
	announced_object = Object.get_by_ap_id(object.data["object"])
	user = User.get_cached_by_ap_id(object.data["actor"])

	Utils.add_announce_to_object(object, announced_object)

	if !User.is_internal_user?(user) do
	Notification.create_notifications(object)
	ActivityPub.stream_out(object)
	end

	{:ok, object, meta}
	end

	def handle(%{data: %{"type" => "Undo", "object" => undone_object}} = object, meta) do
	with undone_object <- Activity.get_by_ap_id(undone_object),
	:ok <- handle_undoing(undone_object) do
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	def handle(%{data: %{"type" => "EmojiReact"}} = object, meta) do
	reacted_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_emoji_reaction_to_object(object, reacted_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Set up notification
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, false) \|\| User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	with {:ok, deleted_object, activity} <- Object.delete(deleted_object),
	%User{} = user <- User.get_cached_by_ap_id(deleted_object.data["actor"]) do
	User.remove_pinnned_activity(user, activity)

	{:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)

	if in_reply_to = deleted_object.data["inReplyTo"] do
	Object.decrease_replies_count(in_reply_to)
	end

	+ ChatMessageReference.delete_for_object(deleted_object)
	+
	ActivityPub.stream_out(object)
	ActivityPub.stream_out_participations(deleted_object, user)
	:ok
	end

	%User{} ->
	with {:ok, _} <- User.delete(deleted_object) do
	:ok
	end
	end

	if result == :ok do
	Notification.create_notifications(object)
	{:ok, object, meta}
	else
	{:error, result}
	end
	end

	# Nothing to do
	def handle(object, meta) do
	{:ok, object, meta}
	end

	def handle_object_creation(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	actor = User.get_cached_by_ap_id(object.data["actor"])
	recipient = User.get_cached_by_ap_id(hd(object.data["to"]))

	[[actor, recipient], [recipient, actor]]
	\|> Enum.each(fn [user, other_user] ->
	if user.local do
	if user.ap_id == actor.ap_id do
	- Chat.get_or_create(user.id, other_user.ap_id)
	+ {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
	+ ChatMessageReference.create(chat, object, true)
	else
	- Chat.bump_or_create(user.id, other_user.ap_id)
	+ {:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	+ ChatMessageReference.create(chat, object, false)
	end
	end
	end)

	Streamer.stream(["user", "user:pleroma_chat"], object)
	{:ok, object, meta}
	end
	end

	# Nothing to do
	def handle_object_creation(object) do
	{:ok, object}
	end

	def handle_undoing(%{data: %{"type" => "Like"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_like_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "EmojiReact"}} = object) do
	with %Object{} = reacted_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_emoji_reaction_from_object(object, reacted_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "Announce"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_announce_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(
	%{data: %{"type" => "Block", "actor" => blocker, "object" => blocked}} = object
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocker),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, _} <- User.unblock(blocker, blocked),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(object), do: {:error, ["don't know how to handle", object]}
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex b/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex
	index 210c8ec4a..c54681054 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex
	@@ -1,138 +1,150 @@
	# 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.ChatController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	- alias Pleroma.Web.PleromaAPI.ChatMessageView
	alias Pleroma.Web.PleromaAPI.ChatView
	+ alias Pleroma.Web.PleromaAPI.ChatMessageReferenceView

	import Ecto.Query
	import Pleroma.Web.ActivityPub.ObjectValidator, only: [stringify_keys: 1]

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:statuses"]}
	when action in [:post_chat_message, :create, :mark_as_read, :delete_message]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:statuses"]} when action in [:messages, :index, :show]
	)

	plug(OpenApiSpex.Plug.CastAndValidate, render_error: Pleroma.Web.ApiSpec.RenderError)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.ChatOperation

	- def delete_message(%{assigns: %{user: %{ap_id: actor} = user}} = conn, %{
	- message_id: id
	+ def delete_message(%{assigns: %{user: %{id: user_id} = user}} = conn, %{
	+ message_id: message_id,
	+ id: chat_id
	}) do
	- with %Object{
	- data: %{
	- "actor" => ^actor,
	- "id" => object,
	- "to" => [recipient],
	- "type" => "ChatMessage"
	- }
	- } = message <- Object.get_by_id(id),
	- %Chat{} = chat <- Chat.get(user.id, recipient),
	- %Activity{} = activity <- Activity.get_create_by_object_ap_id(object),
	- {:ok, _delete} <- CommonAPI.delete(activity.id, user) do
	+ with %ChatMessageReference{} = cm_ref <-
	+ ChatMessageReference.get_by_id(message_id),
	+ ^chat_id <- cm_ref.chat_id \|> to_string(),
	+ %Chat{user_id: ^user_id} <- Chat.get_by_id(chat_id),
	+ {:ok, _} <- remove_or_delete(cm_ref, user) do
	conn
	- \|> put_view(ChatMessageView)
	- \|> render("show.json", for: user, object: message, chat: chat)
	+ \|> put_view(ChatMessageReferenceView)
	+ \|> render("show.json", chat_message_reference: cm_ref)
	else
	- _e -> {:error, :could_not_delete}
	+ _e ->
	+ {:error, :could_not_delete}
	end
	end

	+ defp remove_or_delete(
	+ %{object: %{data: %{"actor" => actor, "id" => id}}},
	+ %{ap_id: actor} = user
	+ ) do
	+ with %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	+ CommonAPI.delete(activity.id, user)
	+ end
	+ end
	+
	+ defp remove_or_delete(cm_ref, _) do
	+ cm_ref
	+ \|> ChatMessageReference.delete()
	+ end
	+
	def post_chat_message(
	%{body_params: params, assigns: %{user: %{id: user_id} = user}} = conn,
	%{
	id: id
	}
	) do
	with %Chat{} = chat <- Repo.get_by(Chat, id: id, user_id: user_id),
	%User{} = recipient <- User.get_cached_by_ap_id(chat.recipient),
	{:ok, activity} <-
	CommonAPI.post_chat_message(user, recipient, params[:content],
	media_id: params[:media_id]
	),
	- message <- Object.normalize(activity) do
	+ message <- Object.normalize(activity, false),
	+ cm_ref <- ChatMessageReference.for_chat_and_object(chat, message) do
	conn
	- \|> put_view(ChatMessageView)
	- \|> render("show.json", for: user, object: message, chat: chat)
	+ \|> put_view(ChatMessageReferenceView)
	+ \|> render("show.json", for: user, chat_message_reference: cm_ref)
	end
	end

	def mark_as_read(%{assigns: %{user: %{id: user_id}}} = conn, %{id: id}) do
	with %Chat{} = chat <- Repo.get_by(Chat, id: id, user_id: user_id),
	{:ok, chat} <- Chat.mark_as_read(chat) do
	conn
	\|> put_view(ChatView)
	\|> render("show.json", chat: chat)
	end
	end

	def messages(%{assigns: %{user: %{id: user_id} = user}} = conn, %{id: id} = params) do
	with %Chat{} = chat <- Repo.get_by(Chat, id: id, user_id: user_id) do
	- messages =
	+ cm_refs =
	chat
	- \|> Chat.messages_for_chat_query()
	+ \|> ChatMessageReference.for_chat_query()
	\|> Pagination.fetch_paginated(params \|> stringify_keys())

	conn
	- \|> put_view(ChatMessageView)
	- \|> render("index.json", for: user, objects: messages, chat: chat)
	+ \|> put_view(ChatMessageReferenceView)
	+ \|> render("index.json", for: user, chat_message_references: cm_refs)
	else
	_ ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "not found"})
	end
	end

	def index(%{assigns: %{user: %{id: user_id} = user}} = conn, params) do
	blocked_ap_ids = User.blocked_users_ap_ids(user)

	chats =
	from(c in Chat,
	where: c.user_id == ^user_id,
	where: c.recipient not in ^blocked_ap_ids,
	order_by: [desc: c.updated_at]
	)
	\|> Pagination.fetch_paginated(params \|> stringify_keys)

	conn
	\|> put_view(ChatView)
	\|> render("index.json", chats: chats)
	end

	def create(%{assigns: %{user: user}} = conn, params) do
	with %User{ap_id: recipient} <- User.get_by_id(params[:id]),
	{:ok, %Chat{} = chat} <- Chat.get_or_create(user.id, recipient) do
	conn
	\|> put_view(ChatView)
	\|> render("show.json", chat: chat)
	end
	end

	def show(%{assigns: %{user: user}} = conn, params) do
	with %Chat{} = chat <- Repo.get_by(Chat, user_id: user.id, id: params[:id]) do
	conn
	\|> put_view(ChatView)
	\|> render("show.json", chat: chat)
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/views/chat_message_view.ex b/lib/pleroma/web/pleroma_api/views/chat_message_reference_view.ex
	similarity index 67%
	rename from lib/pleroma/web/pleroma_api/views/chat_message_view.ex
	rename to lib/pleroma/web/pleroma_api/views/chat_message_reference_view.ex
	index b088a8734..ff170e162 100644
	--- a/lib/pleroma/web/pleroma_api/views/chat_message_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/chat_message_reference_view.ex
	@@ -1,36 +1,45 @@
	# 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.ChatMessageView do
	+defmodule Pleroma.Web.PleromaAPI.ChatMessageReferenceView do
	use Pleroma.Web, :view

	- alias Pleroma.Chat
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.StatusView

	def render(
	"show.json",
	%{
	- object: %{id: id, data: %{"type" => "ChatMessage"} = chat_message},
	- chat: %Chat{id: chat_id}
	+ chat_message_reference: %{
	+ id: id,
	+ object: %{data: chat_message},
	+ chat_id: chat_id,
	+ seen: seen
	+ }
	}
	) do
	%{
	id: id \|> to_string(),
	content: chat_message["content"],
	chat_id: chat_id \|> to_string(),
	account_id: User.get_cached_by_ap_id(chat_message["actor"]).id,
	created_at: Utils.to_masto_date(chat_message["published"]),
	emojis: StatusView.build_emojis(chat_message["emoji"]),
	attachment:
	chat_message["attachment"] &&
	- StatusView.render("attachment.json", attachment: chat_message["attachment"])
	+ StatusView.render("attachment.json", attachment: chat_message["attachment"]),
	+ seen: seen
	}
	end

	def render("index.json", opts) do
	- render_many(opts[:objects], __MODULE__, "show.json", Map.put(opts, :as, :object))
	+ render_many(
	+ opts[:chat_message_references],
	+ __MODULE__,
	+ "show.json",
	+ Map.put(opts, :as, :chat_message_reference)
	+ )
	end
	end
	diff --git a/priv/repo/migrations/20200602150528_create_chat_message_reference.exs b/priv/repo/migrations/20200602150528_create_chat_message_reference.exs
	new file mode 100644
	index 000000000..6f9148b7c
	--- /dev/null
	+++ b/priv/repo/migrations/20200602150528_create_chat_message_reference.exs
	@@ -0,0 +1,20 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Repo.Migrations.CreateChatMessageReference do
	+ use Ecto.Migration
	+
	+ def change do
	+ create table(:chat_message_references, primary_key: false) do
	+ add(:id, :uuid, primary_key: true)
	+ add(:chat_id, references(:chats, on_delete: :delete_all), null: false)
	+ add(:object_id, references(:objects, on_delete: :delete_all), null: false)
	+ add(:seen, :boolean, default: false, null: false)
	+
	+ timestamps()
	+ end
	+
	+ create(index(:chat_message_references, [:chat_id, "id desc"]))
	+ end
	+end
	diff --git a/test/web/activity_pub/side_effects_test.exs b/test/web/activity_pub/side_effects_test.exs
	index 210ba6ef0..ff6b3ac15 100644
	--- a/test/web/activity_pub/side_effects_test.exs
	+++ b/test/web/activity_pub/side_effects_test.exs
	@@ -1,457 +1,468 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Mock

	describe "delete objects" do
	setup do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, op} = CommonAPI.post(other_user, %{status: "big oof"})
	{:ok, post} = CommonAPI.post(user, %{status: "hey", in_reply_to_id: op})
	{:ok, favorite} = CommonAPI.favorite(user, post.id)
	object = Object.normalize(post)
	{:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)

	%{
	user: user,
	delete: delete,
	post: post,
	object: object,
	delete_user: delete_user,
	op: op,
	favorite: favorite
	}
	end

	test "it handles object deletions", %{
	delete: delete,
	post: post,
	object: object,
	user: user,
	op: op,
	favorite: favorite
	} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
	stream_out: fn _ -> nil end,
	stream_out_participations: fn _, _ -> nil end do
	{:ok, delete, _} = SideEffects.handle(delete)
	user = User.get_cached_by_ap_id(object.data["actor"])

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
	end

	object = Object.get_by_id(object.id)
	assert object.data["type"] == "Tombstone"
	refute Activity.get_by_id(post.id)
	refute Activity.get_by_id(favorite.id)

	user = User.get_by_id(user.id)
	assert user.note_count == 0

	object = Object.normalize(op.data["object"], false)

	assert object.data["repliesCount"] == 0
	end

	test "it handles object deletions when the object itself has been pruned", %{
	delete: delete,
	post: post,
	object: object,
	user: user,
	op: op
	} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
	stream_out: fn _ -> nil end,
	stream_out_participations: fn _, _ -> nil end do
	{:ok, delete, _} = SideEffects.handle(delete)
	user = User.get_cached_by_ap_id(object.data["actor"])

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
	end

	object = Object.get_by_id(object.id)
	assert object.data["type"] == "Tombstone"
	refute Activity.get_by_id(post.id)

	user = User.get_by_id(user.id)
	assert user.note_count == 0

	object = Object.normalize(op.data["object"], false)

	assert object.data["repliesCount"] == 0
	end

	test "it handles user deletions", %{delete_user: delete, user: user} do
	{:ok, _delete, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	assert User.get_cached_by_ap_id(user.ap_id).deactivated
	end
	end

	describe "EmojiReact objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
	{:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)

	%{emoji_react: emoji_react, user: user, poster: poster}
	end

	test "adds the reaction to the object", %{emoji_react: emoji_react, user: user} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	object = Object.get_by_ap_id(emoji_react.data["object"])

	assert object.data["reaction_count"] == 1
	assert ["👌", [user.ap_id]] in object.data["reactions"]
	end

	test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: emoji_react.id)
	end
	end

	describe "delete users with confirmation pending" do
	setup do
	user = insert(:user, confirmation_pending: true)
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
	{:ok, delete: delete_user, user: user}
	end

	test "when activation is not required", %{delete: delete, user: user} do
	clear_config([:instance, :account_activation_required], false)
	{:ok, _, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	assert User.get_cached_by_id(user.id).deactivated
	end

	test "when activation is required", %{delete: delete, user: user} do
	clear_config([:instance, :account_activation_required], true)
	{:ok, _, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	refute User.get_cached_by_id(user.id)
	end
	end

	describe "Undo objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, like} = CommonAPI.favorite(user, post.id)
	{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
	{:ok, announce} = CommonAPI.repeat(post.id, user)
	{:ok, block} = ActivityPub.block(user, poster)
	User.block(user, poster)

	{:ok, undo_data, _meta} = Builder.undo(user, like)
	{:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, reaction)
	{:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, announce)
	{:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, block)
	{:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	%{
	like_undo: like_undo,
	post: post,
	like: like,
	reaction_undo: reaction_undo,
	reaction: reaction,
	announce_undo: announce_undo,
	announce: announce,
	block_undo: block_undo,
	block: block,
	poster: poster,
	user: user
	}
	end

	test "deletes the original block", %{block_undo: block_undo, block: block} do
	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute Activity.get_by_id(block.id)
	end

	test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
	blocker = User.get_by_ap_id(block.data["actor"])
	blocked = User.get_by_ap_id(block.data["object"])

	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute User.blocks?(blocker, blocked)
	end

	test "an announce undo removes the announce from the object", %{
	announce_undo: announce_undo,
	post: post
	} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["announcement_count"] == 0
	assert object.data["announcements"] == []
	end

	test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
	refute Activity.get_by_id(announce.id)
	end

	test "a reaction undo removes the reaction from the object", %{
	reaction_undo: reaction_undo,
	post: post
	} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["reaction_count"] == 0
	assert object.data["reactions"] == []
	end

	test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
	refute Activity.get_by_id(reaction.id)
	end

	test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["like_count"] == 0
	assert object.data["likes"] == []
	end

	test "deletes the original like", %{like_undo: like_undo, like: like} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)
	refute Activity.get_by_id(like.id)
	end
	end

	describe "like objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, like_data, _meta} = Builder.like(user, post.object)
	{:ok, like, _meta} = ActivityPub.persist(like_data, local: true)

	%{like: like, user: user, poster: poster}
	end

	test "add the like to the original object", %{like: like, user: user} do
	{:ok, like, _} = SideEffects.handle(like)
	object = Object.get_by_ap_id(like.data["object"])
	assert object.data["like_count"] == 1
	assert user.ap_id in object.data["likes"]
	end

	test "creates a notification", %{like: like, poster: poster} do
	{:ok, like, _} = SideEffects.handle(like)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
	end
	end

	describe "creation of ChatMessages" do
	test "notifies the recipient" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert Repo.get_by(Notification, user_id: recipient.id, activity_id: create_activity.id)
	end

	test "it streams the created ChatMessage" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	with_mock Pleroma.Web.Streamer, [], stream: fn _, _ -> nil end do
	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	object = Object.normalize(create_activity, false)

	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], object))
	end
	end

	- test "it creates a Chat for the local users and bumps the unread count, except for the author" do
	+ test "it creates a Chat and ChatMessageReferences for the local users and bumps the unread count, except for the author" do
	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	chat = Chat.get(author.id, recipient.ap_id)
	assert chat.unread == 0

	+ [cm_ref] = ChatMessageReference.for_chat_query(chat) \|> Repo.all()
	+
	+ assert cm_ref.object.data["content"] == "hey"
	+ assert cm_ref.seen == true
	+
	chat = Chat.get(recipient.id, author.ap_id)
	assert chat.unread == 1
	+
	+ [cm_ref] = ChatMessageReference.for_chat_query(chat) \|> Repo.all()
	+
	+ assert cm_ref.object.data["content"] == "hey"
	+ assert cm_ref.seen == false
	end

	test "it creates a Chat for the local users and bumps the unread count" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# An object is created
	assert Object.get_by_ap_id(chat_message_data["id"])

	# The remote user won't get a chat
	chat = Chat.get(author.id, recipient.ap_id)
	refute chat

	# The local user will get a chat
	chat = Chat.get(recipient.id, author.ap_id)
	assert chat

	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# Both users are local and get the chat
	chat = Chat.get(author.id, recipient.ap_id)
	assert chat

	chat = Chat.get(recipient.id, author.ap_id)
	assert chat
	end
	end

	describe "announce objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, private_post} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, announce_data, _meta} = Builder.announce(user, post.object, public: true)

	{:ok, private_announce_data, _meta} =
	Builder.announce(user, private_post.object, public: false)

	{:ok, relay_announce_data, _meta} =
	Builder.announce(Pleroma.Web.ActivityPub.Relay.get_actor(), post.object, public: true)

	{:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)
	{:ok, private_announce, _meta} = ActivityPub.persist(private_announce_data, local: true)
	{:ok, relay_announce, _meta} = ActivityPub.persist(relay_announce_data, local: true)

	%{
	announce: announce,
	user: user,
	poster: poster,
	private_announce: private_announce,
	relay_announce: relay_announce
	}
	end

	test "adds the announce to the original object", %{announce: announce, user: user} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == 1
	assert user.ap_id in object.data["announcements"]
	end

	test "does not add the announce to the original object if the actor is a service actor", %{
	relay_announce: announce
	} do
	{:ok, announce, _} = SideEffects.handle(announce)
	object = Object.get_by_ap_id(announce.data["object"])
	assert object.data["announcement_count"] == nil
	end

	test "creates a notification", %{announce: announce, poster: poster} do
	{:ok, announce, _} = SideEffects.handle(announce)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: announce.id)
	end

	test "it streams out the announce", %{announce: announce} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough], stream_out: fn _ -> nil end do
	{:ok, announce, _} = SideEffects.handle(announce)

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(announce))
	end
	end
	end
	end
	diff --git a/test/web/pleroma_api/controllers/chat_controller_test.exs b/test/web/pleroma_api/controllers/chat_controller_test.exs
	index d79aa3148..bd4024c09 100644
	--- a/test/web/pleroma_api/controllers/chat_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/chat_controller_test.exs
	@@ -1,298 +1,308 @@
	# 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.ChatControllerTest do
	use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "POST /api/v1/pleroma/chats/:id/read" do
	setup do: oauth_access(["write:statuses"])

	test "it marks all messages in a chat as read", %{conn: conn, user: user} do
	other_user = insert(:user)

	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)

	assert chat.unread == 1

	result =
	conn
	\|> post("/api/v1/pleroma/chats/#{chat.id}/read")
	\|> json_response_and_validate_schema(200)

	assert result["unread"] == 0

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

	assert chat.unread == 0
	end
	end

	describe "POST /api/v1/pleroma/chats/:id/messages" do
	setup do: oauth_access(["write:statuses"])

	test "it posts a message to the chat", %{conn: conn, user: user} do
	other_user = insert(:user)

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

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "Hallo!!"})
	\|> json_response_and_validate_schema(200)

	assert result["content"] == "Hallo!!"
	assert result["chat_id"] == chat.id \|> to_string()
	end

	test "it fails if there is no content", %{conn: conn, user: user} do
	other_user = insert(:user)

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

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(400)

	assert result
	end

	test "it works with an attachment", %{conn: conn, user: user} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

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

	other_user = insert(:user)

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

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{
	"media_id" => to_string(upload.id)
	})
	\|> json_response_and_validate_schema(200)

	assert result["attachment"]
	end
	end

	describe "DELETE /api/v1/pleroma/chats/:id/messages/:message_id" do
	setup do: oauth_access(["write:statuses"])

	- test "it deletes a message for the author of the message", %{conn: conn, user: user} do
	+ test "it deletes a message from the chat", %{conn: conn, user: user} do
	recipient = insert(:user)

	{:ok, message} =
	CommonAPI.post_chat_message(user, recipient, "Hello darkness my old friend")

	{:ok, other_message} = CommonAPI.post_chat_message(recipient, user, "nico nico ni")

	object = Object.normalize(message, false)

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

	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)
	+
	+ # Deleting your own message removes the message and the reference
	result =
	conn
	\|> put_req_header("content-type", "application/json")
	- \|> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{object.id}")
	+ \|> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
	\|> json_response_and_validate_schema(200)

	- assert result["id"] == to_string(object.id)
	+ assert result["id"] == cm_ref.id
	+ refute ChatMessageReference.get_by_id(cm_ref.id)
	+ assert %{data: %{"type" => "Tombstone"}} = Object.get_by_id(object.id)

	+ # Deleting other people's messages just removes the reference
	object = Object.normalize(other_message, false)
	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	- \|> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{object.id}")
	- \|> json_response(400)
	+ \|> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
	+ \|> json_response_and_validate_schema(200)

	- assert result == %{"error" => "could_not_delete"}
	+ assert result["id"] == cm_ref.id
	+ refute ChatMessageReference.get_by_id(cm_ref.id)
	+ assert Object.get_by_id(object.id)
	end
	end

	describe "GET /api/v1/pleroma/chats/:id/messages" do
	setup do: oauth_access(["read:statuses"])

	test "it paginates", %{conn: conn, user: user} do
	recipient = insert(:user)

	Enum.each(1..30, fn _ ->
	{:ok, _} = CommonAPI.post_chat_message(user, recipient, "hey")
	end)

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

	result =
	conn
	\|> get("/api/v1/pleroma/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 20

	result =
	conn
	\|> get("/api/v1/pleroma/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 10
	end

	test "it returns the messages for a given chat", %{conn: conn, user: user} do
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, _} = CommonAPI.post_chat_message(user, other_user, "hey")
	{:ok, _} = CommonAPI.post_chat_message(user, third_user, "hey")
	{:ok, _} = CommonAPI.post_chat_message(user, other_user, "how are you?")
	{:ok, _} = CommonAPI.post_chat_message(other_user, user, "fine, how about you?")

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

	result =
	conn
	\|> get("/api/v1/pleroma/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(200)

	result
	\|> Enum.each(fn message ->
	assert message["chat_id"] == chat.id \|> to_string()
	end)

	assert length(result) == 3

	# Trying to get the chat of a different user
	result =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/pleroma/chats/#{chat.id}/messages")

	assert result \|> json_response(404)
	end
	end

	describe "POST /api/v1/pleroma/chats/by-account-id/:id" do
	setup do: oauth_access(["write:statuses"])

	test "it creates or returns a chat", %{conn: conn} do
	other_user = insert(:user)

	result =
	conn
	\|> post("/api/v1/pleroma/chats/by-account-id/#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"]
	end
	end

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

	test "it returns a chat", %{conn: conn, user: user} do
	other_user = insert(:user)

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

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

	assert result["id"] == to_string(chat.id)
	end
	end

	describe "GET /api/v1/pleroma/chats" do
	setup do: oauth_access(["read:statuses"])

	test "it does not return chats with users you blocked", %{conn: conn, user: user} do
	recipient = insert(:user)

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

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1

	User.block(user, recipient)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 0
	end

	test "it paginates", %{conn: conn, user: user} do
	Enum.each(1..30, fn _ ->
	recipient = insert(:user)
	{:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
	end)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 20

	result =
	conn
	\|> get("/api/v1/pleroma/chats?max_id=#{List.last(result)["id"]}")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 10
	end

	test "it return a list of chats the current user is participating in, in descending order of updates",
	%{conn: conn, user: user} do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, chat_1} = Chat.get_or_create(user.id, har.ap_id)
	:timer.sleep(1000)
	{:ok, _chat_2} = Chat.get_or_create(user.id, jafnhar.ap_id)
	:timer.sleep(1000)
	{:ok, chat_3} = Chat.get_or_create(user.id, tridi.ap_id)
	:timer.sleep(1000)

	# bump the second one
	{:ok, chat_2} = Chat.bump_or_create(user.id, jafnhar.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	ids = Enum.map(result, & &1["id"])

	assert ids == [
	chat_2.id \|> to_string(),
	chat_3.id \|> to_string(),
	chat_1.id \|> to_string()
	]
	end
	end
	end
	diff --git a/test/web/pleroma_api/views/chat_message_view_test.exs b/test/web/pleroma_api/views/chat_message_reference_view_test.exs
	similarity index 67%
	rename from test/web/pleroma_api/views/chat_message_view_test.exs
	rename to test/web/pleroma_api/views/chat_message_reference_view_test.exs
	index d7a2d10a5..00024d52c 100644
	--- a/test/web/pleroma_api/views/chat_message_view_test.exs
	+++ b/test/web/pleroma_api/views/chat_message_reference_view_test.exs
	@@ -1,54 +1,62 @@
	# 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.ChatMessageReferenceViewTest do
	use Pleroma.DataCase

	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	- alias Pleroma.Web.PleromaAPI.ChatMessageView
	+ alias Pleroma.Web.PleromaAPI.ChatMessageReferenceView

	import Pleroma.Factory

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

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

	{:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "kippis :firefox:")

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

	object = Object.normalize(activity)

	- chat_message = ChatMessageView.render("show.json", object: object, for: user, chat: chat)
	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)

	- assert chat_message[:id] == object.id \|> to_string()
	+ chat_message = ChatMessageReferenceView.render("show.json", chat_message_reference: cm_ref)
	+
	+ assert chat_message[:id] == cm_ref.id
	assert chat_message[:content] == "kippis :firefox:"
	assert chat_message[:account_id] == user.id
	assert chat_message[:chat_id]
	assert chat_message[:created_at]
	+ assert chat_message[:seen] == true
	assert match?([%{shortcode: "firefox"}], chat_message[:emojis])

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

	object = Object.normalize(activity)

	- chat_message_two = ChatMessageView.render("show.json", object: object, for: user, chat: chat)
	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)
	+
	+ chat_message_two =
	+ ChatMessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	- assert chat_message_two[:id] == object.id \|> to_string()
	+ assert chat_message_two[:id] == cm_ref.id
	assert chat_message_two[:content] == "gkgkgk"
	assert chat_message_two[:account_id] == recipient.id
	assert chat_message_two[:chat_id] == chat_message[:chat_id]
	assert chat_message_two[:attachment]
	+ assert chat_message_two[:seen] == false
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Oct 12, 8:20 PM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786445
Default Alt Text: (50 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions