No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/pipeline-response-counter-cache.fix b/changelog.d/pipeline-response-counter-cache.fix
	new file mode 100644
	index 000000000..dd1b337fb
	--- /dev/null
	+++ b/changelog.d/pipeline-response-counter-cache.fix
	@@ -0,0 +1 @@
	+Refresh cached objects after reply and quote counter updates, preventing subsequent poll votes from overwriting those counts with stale data.
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index 5e9314446..ddac7a52f 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,477 +1,481 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object do
	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Hashtag
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.ObjectTombstone
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Workers.AttachmentsCleanupWorker

	require Logger

	@type t() :: %__MODULE__{}

	@derive {Jason.Encoder, only: [:data]}

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

	schema "objects" do
	field(:data, :map)

	many_to_many(:hashtags, Hashtag, join_through: "hashtags_objects", on_replace: :delete)

	timestamps()
	end

	def with_joined_activity(query, activity_type \\ "Create", join_type \\ :inner) do
	object_position = Map.get(query.aliases, :object, 0)

	join(query, join_type, [{object, object_position}], a in Activity,
	on:
	fragment(
	"associated_object_id(?) = (? ->> 'id') AND (?->>'type' = ?) ",
	a.data,
	object.data,
	a.data,
	^activity_type
	),
	as: :object_activity
	)
	end

	def create(data) do
	%Object{}
	\|> Object.change(%{data: data})
	\|> Repo.insert()
	end

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :objects_unique_apid_index)
	# Expecting `maybe_handle_hashtags_change/1` to run last:
	\|> maybe_handle_hashtags_change(struct)
	end

	# Note: not checking activity type (assuming non-legacy objects are associated with Create act.)
	defp maybe_handle_hashtags_change(changeset, struct) do
	with %Ecto.Changeset{valid?: true} <- changeset,
	data_hashtags_change = get_change(changeset, :data),
	{_, true} <- {:changed, hashtags_changed?(struct, data_hashtags_change)},
	{:ok, hashtag_records} <-
	data_hashtags_change
	\|> object_data_hashtags()
	\|> Hashtag.get_or_create_by_names() do
	put_assoc(changeset, :hashtags, hashtag_records)
	else
	%{valid?: false} ->
	changeset

	{:changed, false} ->
	changeset

	{:error, _} ->
	validate_change(changeset, :data, fn _, _ ->
	[data: "error referencing hashtags"]
	end)
	end
	end

	defp hashtags_changed?(%Object{} = struct, %{"tag" => _} = data) do
	Enum.sort(embedded_hashtags(struct)) !=
	Enum.sort(object_data_hashtags(data))
	end

	defp hashtags_changed?(_, _), do: false

	def get_by_id(nil), do: nil
	def get_by_id(id), do: Repo.get(Object, id)

	def get_by_ap_id(nil), do: nil

	def get_by_ap_id(ap_id) do
	Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
	end

	@doc """
	Get a single attachment by it's name and href
	"""
	@spec get_attachment_by_name_and_href(String.t(), String.t()) :: Object.t() \| nil
	def get_attachment_by_name_and_href(name, href) do
	query =
	from(o in Object,
	where: fragment("(?)->>'name' = ?", o.data, ^name),
	where: fragment("(?)->>'href' = ?", o.data, ^href)
	)

	Repo.one(query)
	end

	defp warn_on_no_object_preloaded(ap_id) do
	"Object.normalize() called without preloaded object (#{inspect(ap_id)}). Consider preloading the object"
	\|> Logger.debug()

	Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
	end

	def normalize(_, options \\ [fetch: false])

	# If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
	# Use this whenever possible, especially when walking graphs in an O(N) loop!
	def normalize(%Object{} = object, _), do: object
	def normalize(%Activity{object: %Object{} = object}, _), do: object

	# A hack for fake activities
	def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _) do
	%Object{id: "pleroma:fake_object_id", data: data}
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, options) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, options)
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => ap_id}}, options) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, options)
	end

	# Old way, try fetching the object through cache.
	def normalize(%{"id" => ap_id}, options), do: normalize(ap_id, options)

	def normalize(ap_id, options) when is_binary(ap_id) do
	cond do
	Keyword.get(options, :fetch) ->
	case Fetcher.fetch_object_from_id(ap_id, options) do
	{:ok, object} -> object
	_ -> nil
	end

	true ->
	get_cached_by_ap_id(ap_id)
	end
	end

	def normalize(_, _), do: nil

	# Owned objects can only be accessed by their owner
	def authorize_access(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}) do
	if actor == ap_id do
	:ok
	else
	{:error, :forbidden}
	end
	end

	# Legacy objects can be accessed by anybody
	def authorize_access(%Object{}, %User{}), do: :ok

	@spec get_cached_by_ap_id(String.t()) :: Object.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "object:#{ap_id}"

	with {:ok, nil} <- @cachex.get(:object_cache, key),
	object when not is_nil(object) <- get_by_ap_id(ap_id),
	{:ok, true} <- @cachex.put(:object_cache, key, object) do
	object
	else
	{:ok, object} -> object
	nil -> nil
	end
	end

	def make_tombstone(%Object{data: %{"id" => id, "type" => type}}, deleted \\ DateTime.utc_now()) do
	%ObjectTombstone{
	id: id,
	formerType: type,
	deleted: deleted
	}
	\|> Map.from_struct()
	end

	def swap_object_with_tombstone(object) do
	tombstone = make_tombstone(object)

	with {:ok, object} <-
	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update() do
	Hashtag.unlink(object)
	{:ok, object}
	end
	end

	def delete(%Object{data: %{"id" => id}} = object) do
	with {:ok, _obj} = swap_object_with_tombstone(object),
	deleted_activity = Activity.delete_all_by_object_ap_id(id),
	{:ok, _} <- invalid_object_cache(object) do
	cleanup_attachments(
	Config.get([:instance, :cleanup_attachments]),
	object
	)

	{:ok, object, deleted_activity}
	end
	end

	@spec cleanup_attachments(boolean(), Object.t()) ::
	{:ok, Oban.Job.t() \| nil}
	def cleanup_attachments(true, %Object{} = object) do
	AttachmentsCleanupWorker.new(%{"op" => "cleanup_attachments", "object" => object})
	\|> Oban.insert()
	end

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

	def prune(%Object{data: %{"id" => _id}} = object) do
	with {:ok, object} <- Repo.delete(object),
	{:ok, _} <- invalid_object_cache(object) do
	{:ok, object}
	end
	end

	def invalid_object_cache(%Object{data: %{"id" => id}}) do
	with {:ok, true} <- @cachex.del(:object_cache, "object:#{id}") do
	@cachex.del(:web_resp_cache, URI.parse(id).path)
	end
	end

	def set_cache(%Object{data: %{"id" => ap_id}} = object) do
	@cachex.put(:object_cache, "object:#{ap_id}", object)
	{:ok, object}
	end

	def update_and_set_cache(changeset) do
	with {:ok, object} <- Repo.update(changeset) do
	set_cache(object)
	end
	end

	def increase_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(coalesce((?->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	+ \|> select([o], o)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	defp poll_is_multiple?(%Object{data: %{"anyOf" => [_ \| _]}}), do: true

	defp poll_is_multiple?(_), do: false

	def decrease_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	+ \|> select([o], o)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_quotes_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{quotesCount}',
	(coalesce((?->>'quotesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	+ \|> select([o], o)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def decrease_quotes_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{quotesCount}',
	(greatest(0, (?->>'quotesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	+ \|> select([o], o)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_vote_count(ap_id, name, actor) do
	with %Object{} = object <- Object.normalize(ap_id, fetch: false),
	"Question" <- object.data["type"] do
	key = if poll_is_multiple?(object), do: "anyOf", else: "oneOf"

	options =
	object.data[key]
	\|> Enum.map(fn
	%{"name" => ^name} = option ->
	Kernel.update_in(option["replies"]["totalItems"], &(&1 + 1))

	option ->
	option
	end)

	existing_voters = object.data["voters"] \|\| []
	voters = [actor \| existing_voters] \|> Enum.uniq()
	new_voter? = actor not in existing_voters
	existing_voters_count = object.data["votersCount"]

	voters_count =
	cond do
	is_integer(existing_voters_count) and new_voter? ->
	existing_voters_count + 1

	is_integer(existing_voters_count) ->
	existing_voters_count

	true ->
	length(voters)
	end

	data =
	object.data
	\|> Map.put(key, options)
	\|> Map.put("voters", voters)
	\|> Map.put("votersCount", voters_count)

	object
	\|> Object.change(%{data: data})
	\|> update_and_set_cache()
	else
	_ -> :noop
	end
	end

	@doc "Updates data field of an object"
	def update_data(%Object{data: data} = object, attrs \\ %{}) do
	object
	\|> Object.change(%{data: Map.merge(data \|\| %{}, attrs)})
	\|> Repo.update()
	end

	def local?(%Object{data: %{"id" => id}}) do
	String.starts_with?(id, Pleroma.Web.Endpoint.url() <> "/")
	end

	def tags(%Object{data: %{"tag" => tags}}) when is_list(tags), do: tags

	def tags(_), do: []

	def hashtags(%Object{} = object) do
	# Note: always using embedded hashtags regardless whether they are migrated to hashtags table
	# (embedded hashtags stay in sync anyways, and we avoid extra joins and preload hassle)
	embedded_hashtags(object)
	end

	def embedded_hashtags(%Object{data: data}) do
	object_data_hashtags(data)
	end

	def embedded_hashtags(_), do: []

	def object_data_hashtags(%{"tag" => tags}) when is_list(tags) do
	tags
	\|> Enum.filter(fn
	%{"type" => "Hashtag"} = data -> Map.has_key?(data, "name")
	plain_text when is_bitstring(plain_text) -> true
	_ -> false
	end)
	\|> Enum.map(fn
	%{"name" => "#" <> hashtag} -> String.downcase(hashtag)
	%{"name" => hashtag} -> String.downcase(hashtag)
	hashtag when is_bitstring(hashtag) -> String.downcase(hashtag)
	end)
	\|> Enum.uniq()
	# Note: "" elements (plain text) might occur in `data.tag` for incoming objects
	\|> Enum.filter(&(&1 not in [nil, ""]))
	end

	def object_data_hashtags(_), do: []

	def get_emoji_reactions(object) do
	reactions = object.data["reactions"]

	if is_list(reactions) or is_map(reactions) do
	reactions
	\|> Enum.map(fn
	[_emoji, users, _maybe_url] = item when is_list(users) ->
	item

	[emoji, users] when is_list(users) ->
	[emoji, users, nil]

	# This case is here to process the Map situation, which will happen
	# only with the legacy two-value format.
	{emoji, users} when is_list(users) ->
	[emoji, users, nil]

	_ ->
	nil
	end)
	\|> Enum.reject(&is_nil/1)
	else
	[]
	end
	end
	end
	diff --git a/test/pleroma/object_test.exs b/test/pleroma/object_test.exs
	index 13e941e4d..4fc0e7ad6 100644
	--- a/test/pleroma/object_test.exs
	+++ b/test/pleroma/object_test.exs
	@@ -1,344 +1,365 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ObjectTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	alias Pleroma.Hashtag
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	ConfigMock \|> stub_with(Pleroma.Test.StaticConfig)
	:ok
	end

	test "returns an object by it's AP id" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object
	end

	+ for {function, field, expected} <- [
	+ {:increase_replies_count, "repliesCount", 3},
	+ {:decrease_replies_count, "repliesCount", 1},
	+ {:increase_quotes_count, "quotesCount", 3},
	+ {:decrease_quotes_count, "quotesCount", 1}
	+ ] do
	+ test "#{function} returns and caches the updated object" do
	+ object = insert(:note, data: %{unquote(field) => 2})
	+ ap_id = object.data["id"]
	+ assert Object.get_cached_by_ap_id(ap_id).data[unquote(field)] == 2
	+
	+ assert {:ok, updated} = apply(Object, unquote(function), [ap_id])
	+ assert updated.data[unquote(field)] == unquote(expected)
	+ assert Object.get_by_ap_id(ap_id) == updated
	+ assert Object.get_cached_by_ap_id(ap_id) == updated
	+
	+ assert {:error, "Not found"} =
	+ apply(Object, unquote(function), ["https://example.com/missing-object"])
	+ end
	+ end
	+
	describe "generic changeset" do
	test "it ensures uniqueness of the id" do
	object = insert(:note)
	cs = Object.change(%Object{}, %{data: %{id: object.data["id"]}})
	assert cs.valid?

	{:error, _result} = Repo.insert(cs)
	end
	end

	describe "deletion function" do
	test "deletes an object" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object

	Object.delete(found_object)

	found_object = Object.get_by_ap_id(object.data["id"])

	refute object == found_object

	assert found_object.data["type"] == "Tombstone"
	end

	test "ensures cache is cleared for the object" do
	object = insert(:note)
	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	assert object == cached_object

	Cachex.put(:web_resp_cache, URI.parse(object.data["id"]).path, "cofe")

	Object.delete(cached_object)

	{:ok, nil} = Cachex.get(:object_cache, "object:#{object.data["id"]}")
	{:ok, nil} = Cachex.get(:web_resp_cache, URI.parse(object.data["id"]).path)

	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	refute object == cached_object

	assert cached_object.data["type"] == "Tombstone"
	end
	end

	describe "delete attachments" do
	setup do: clear_config([Pleroma.Upload])
	setup do: clear_config([:instance, :cleanup_attachments])

	test "Disabled via config" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:instance, :cleanup_attachments], false)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	refute Object.get_by_id(attachment.id) == nil

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")
	end

	test "in subdirectories" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:instance, :cleanup_attachments], true)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end

	test "with dedupe enabled" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([Pleroma.Upload, :filters], [Pleroma.Upload.Filter.Dedupe])
	clear_config([:instance, :cleanup_attachments], true)

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	Pleroma.Backports.mkdir_p!(uploads_dir)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	filename = Path.basename(href)

	expected_path = Path.join([uploads_dir, Pleroma.Upload.Filter.Dedupe.shard_path(filename)])

	assert File.exists?(expected_path)

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil
	refute File.exists?(expected_path)
	end

	test "with objects that have legacy data.url attribute" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:instance, :cleanup_attachments], true)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %Object{}} = Object.create(%{url: "https://google.com", actor: user.ap_id})

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end

	test "With custom base_url" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([Pleroma.Upload, :base_url], "https://sub.domain.tld/dir/")
	clear_config([:instance, :cleanup_attachments], true)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end
	end

	describe "normalizer" do
	@url "http://mastodon.example.org/@admin/99541947525187367"
	test "does not fetch unknown objects by default" do
	assert nil == Object.normalize(@url)
	end

	test "fetches unknown objects when fetch is explicitly true" do
	%Object{} = object = Object.normalize(@url, fetch: true)

	assert object.data["url"] == @url
	end

	test "does not fetch unknown objects when fetch is false" do
	assert is_nil(
	Object.normalize(@url,
	fetch: false
	)
	)
	end
	end

	describe ":hashtags association" do
	test "Hashtag records are created with Object record and updated on its change" do
	user = insert(:user)

	{:ok, %{object: object}} =
	CommonAPI.post(user, %{status: "some text #hashtag1 #hashtag2 ..."})

	assert [%Hashtag{name: "hashtag1"}, %Hashtag{name: "hashtag2"}] =
	Enum.sort_by(object.hashtags, & &1.name)

	{:ok, object} = Object.update_data(object, %{"tag" => []})

	assert [] = object.hashtags

	object = Object.get_by_id(object.id) \|> Repo.preload(:hashtags)
	assert [] = object.hashtags

	{:ok, object} = Object.update_data(object, %{"tag" => ["abc", "def"]})

	assert [%Hashtag{name: "abc"}, %Hashtag{name: "def"}] =
	Enum.sort_by(object.hashtags, & &1.name)
	end
	end

	describe "get_emoji_reactions/1" do
	test "3-tuple current format" do
	object = %Object{
	data: %{
	"reactions" => [
	["x", ["https://some/user"], "https://some/emoji"]
	]
	}
	}

	assert Object.get_emoji_reactions(object) == object.data["reactions"]
	end

	test "2-tuple legacy format" do
	object = %Object{
	data: %{
	"reactions" => [
	["x", ["https://some/user"]]
	]
	}
	}

	assert Object.get_emoji_reactions(object) == [["x", ["https://some/user"], nil]]
	end

	test "Map format" do
	object = %Object{
	data: %{
	"reactions" => %{
	"x" => ["https://some/user"]
	}
	}
	}

	assert Object.get_emoji_reactions(object) == [["x", ["https://some/user"], nil]]
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
	index 1eb1e665e..c141059ee 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
	@@ -1,125 +1,168 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.AnswerHandlingTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "incoming, rewrites Note to Answer and increments vote counters" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	object = Object.normalize(activity, fetch: false)
	assert object.data["repliesCount"] == nil

	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Jason.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	answer_object = Object.normalize(activity, fetch: false)
	assert answer_object.data["type"] == "Answer"
	assert answer_object.data["inReplyTo"] == object.data["id"]

	new_object = Object.get_by_ap_id(object.data["id"])
	assert new_object.data["repliesCount"] == nil

	assert Enum.any?(
	new_object.data["oneOf"],
	fn
	%{"name" => "suya..", "replies" => %{"totalItems" => 1}} -> true
	_ -> false
	end
	)
	end

	+ for {multiple, options_key} <- [{false, "oneOf"}, {true, "anyOf"}] do
	+ test "incoming vote preserves existing reply and quote counts for #{options_key} polls" do
	+ user = insert(:user)
	+
	+ {:ok, poll} =
	+ CommonAPI.post(user, %{
	+ status: "suya...",
	+ poll: %{
	+ options: ["suya", "suya.", "suya.."],
	+ expires_in: 600,
	+ multiple: unquote(multiple)
	+ }
	+ })
	+
	+ ap_id = poll.object.data["id"]
	+ Object.get_cached_by_ap_id(ap_id)
	+
	+ {:ok, _reply} =
	+ CommonAPI.post(user, %{status: "a real reply", in_reply_to_status_id: poll.id})
	+
	+ {:ok, _quote} = CommonAPI.post(user, %{status: "a quote", quoted_status_id: poll.id})
	+ assert %{"repliesCount" => 1, "quotesCount" => 1} = Object.get_by_ap_id(ap_id).data
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-vote.json")
	+ \|> Jason.decode!()
	+ \|> put_in(["to"], user.ap_id)
	+ \|> put_in(["object", "to"], user.ap_id)
	+ \|> put_in(["object", "inReplyTo"], ap_id)
	+
	+ {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
	+ updated = Object.get_by_ap_id(ap_id)
	+
	+ assert %{"repliesCount" => 1, "quotesCount" => 1, "votersCount" => 1} = updated.data
	+ assert data["actor"] in updated.data["voters"]
	+
	+ option = Enum.find(updated.data[unquote(options_key)], &(&1["name"] == "suya.."))
	+ assert option["replies"]["totalItems"] == 1
	+
	+ assert Object.get_cached_by_ap_id(ap_id) == updated
	+ end
	+ end
	+
	for public_field <- ["to", "cc"] do
	test "deleting a vote with Public in #{public_field} preserves the poll's reply count" do
	user = insert(:user)

	{:ok, poll} =
	CommonAPI.post(user, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 600}
	})

	recipients =
	%{"to" => [user.ap_id], "cc" => []}
	\|> Map.put(unquote(public_field), ["https://www.w3.org/ns/activitystreams#Public"])

	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Jason.decode!()
	\|> Map.merge(recipients)
	\|> update_in(["object"], &Map.merge(&1, recipients))
	\|> put_in(["object", "inReplyTo"], poll.object.data["id"])

	{:ok, %Activity{local: false} = answer} = Transmogrifier.handle_incoming(data)
	assert Object.normalize(answer).data["type"] == "Answer"
	assert Pleroma.Web.ActivityPub.Visibility.public?(Object.normalize(answer))

	{:ok, reply} =
	CommonAPI.post(user, %{status: "a real reply", in_reply_to_status_id: poll.id})

	assert Object.get_by_ap_id(poll.object.data["id"]).data["repliesCount"] == 1

	{:ok, _delete} =
	Transmogrifier.handle_incoming(%{
	"id" => answer.data["id"] <> "/delete",
	"type" => "Delete",
	"actor" => answer.actor,
	"object" => answer.data["object"]
	})

	refute Activity.get_by_id(answer.id)
	assert Object.get_by_ap_id(poll.object.data["id"]).data["repliesCount"] == 1

	{:ok, _delete} = CommonAPI.delete(reply.id, user)
	assert Object.get_by_ap_id(poll.object.data["id"]).data["repliesCount"] == 0
	end
	end

	test "outgoing, rewrites Answer to Note" do
	user = insert(:user)

	{:ok, poll_activity} =
	CommonAPI.post(user, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	poll_object = Object.normalize(poll_activity, fetch: false)
	# TODO: Replace with CommonAPI vote creation when implemented
	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Jason.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], poll_object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	{:ok, data} = Transmogrifier.prepare_activity(activity.data)

	assert data["object"]["type"] == "Note"
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 12:11 PM (1 d, 22 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1763124
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions