No OneTemporary
Actions

Authored By

Unknown

Size

27 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/poll-voters-count-inflation.fix b/changelog.d/poll-voters-count-inflation.fix
	new file mode 100644
	index 000000000..7eae41f13
	--- /dev/null
	+++ b/changelog.d/poll-voters-count-inflation.fix
	@@ -0,0 +1 @@
	+Fix votersCount inflation when same voter picks multiple options
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index f1e07a257..5e9314446 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,469 +1,477 @@
	# 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
	)
	]
	)
	\|> 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
	)
	]
	)
	\|> 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
	)
	]
	)
	\|> 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
	)
	]
	)
	\|> 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)

	- voters = [actor \| object.data["voters"] \|\| []] \|> Enum.uniq()
	+ 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 =
	- if Map.has_key?(object.data, "votersCount") do
	- object.data["votersCount"] + 1
	- else
	- length(voters)
	+ 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/lib/pleroma/web/mastodon_api/views/poll_view.ex b/lib/pleroma/web/mastodon_api/views/poll_view.ex
	index 3b4271227..f047804e2 100644
	--- a/lib/pleroma/web/mastodon_api/views/poll_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/poll_view.ex
	@@ -1,107 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.PollView do
	use Pleroma.Web, :view

	alias Pleroma.Web.CommonAPI.Utils

	def render("show.json", %{object: object, multiple: multiple, options: options} = params) do
	{end_time, expired} = end_time_and_expired(object)
	{options, votes_count} = options_and_votes_count(options)

	poll = %{
	# Mastodon uses separate ids for polls, but an object can't have
	# more than one poll embedded so object id is fine
	id: to_string(object.id),
	expires_at: end_time,
	expired: expired,
	multiple: multiple,
	votes_count: votes_count,
	voters_count: voters_count(object),
	options: options,
	emojis: Pleroma.Web.MastodonAPI.StatusView.build_emojis(object.data["emoji"]),
	pleroma: %{
	non_anonymous: object.data["nonAnonymous"] \|\| false
	}
	}

	if params[:for] do
	# when unauthenticated Mastodon doesn't include `voted` & `own_votes` keys in response
	{voted, own_votes} = voted_and_own_votes(params, options)
	Map.merge(poll, %{voted: voted, own_votes: own_votes})
	else
	poll
	end
	end

	def render("show.json", %{object: object} = params) do
	case object.data do
	%{"anyOf" => [_ \| _] = options} ->
	render(__MODULE__, "show.json", Map.merge(params, %{multiple: true, options: options}))

	%{"oneOf" => [_ \| _] = options} ->
	render(__MODULE__, "show.json", Map.merge(params, %{multiple: false, options: options}))

	_ ->
	nil
	end
	end

	defp end_time_and_expired(object) do
	if object.data["closed"] do
	end_time = NaiveDateTime.from_iso8601!(object.data["closed"])
	expired = NaiveDateTime.compare(end_time, NaiveDateTime.utc_now()) == :lt

	{Utils.to_masto_date(end_time), expired}
	else
	{nil, false}
	end
	end

	defp options_and_votes_count(options) do
	Enum.map_reduce(options, 0, fn %{"name" => name} = option, count ->
	current_count = option["replies"]["totalItems"] \|\| 0

	{%{
	title: name,
	votes_count: current_count
	}, current_count + count}
	end)
	end

	+ defp voters_count(%{data: %{"votersCount" => voters}}) when is_integer(voters), do: voters
	+
	defp voters_count(%{data: %{"voters" => [_ \| _] = voters}}) do
	length(voters)
	end

	- defp voters_count(%{data: %{"votersCount" => voters}}), do: voters
	-
	defp voters_count(_), do: 0

	defp voted_and_own_votes(%{object: object} = params, options) do
	if params[:for] do
	existing_votes =
	Pleroma.Web.ActivityPub.Utils.get_existing_votes(params[:for].ap_id, object)

	voted = existing_votes != [] or params[:for].ap_id == object.data["actor"]

	own_votes =
	if voted do
	titles = Enum.map(options, & &1[:title])

	Enum.reduce(existing_votes, [], fn vote, acc ->
	data = vote \|> Map.get(:object) \|> Map.get(:data)
	index = Enum.find_index(titles, &(&1 == data["name"]))
	[index \| acc]
	end)
	else
	[]
	end

	{voted, own_votes}
	else
	{false, []}
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/poll_view_test.exs b/test/pleroma/web/mastodon_api/views/poll_view_test.exs
	index 16281393d..6cb5934de 100644
	--- a/test/pleroma/web/mastodon_api/views/poll_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/poll_view_test.exs
	@@ -1,183 +1,358 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.PollViewTest do
	use Pleroma.DataCase

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.PollView

	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "renders a poll" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Is Tenshi eating a corndog cute?",
	poll: %{
	options: ["absolutely!", "sure", "yes", "why are you even asking?"],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)

	expected = %{
	emojis: [],
	expired: false,
	id: to_string(object.id),
	multiple: false,
	options: [
	%{title: "absolutely!", votes_count: 0},
	%{title: "sure", votes_count: 0},
	%{title: "yes", votes_count: 0},
	%{title: "why are you even asking?", votes_count: 0}
	],
	votes_count: 0,
	voters_count: 0,
	pleroma: %{non_anonymous: false}
	}

	result = PollView.render("show.json", %{object: object})
	expires_at = result.expires_at
	result = Map.delete(result, :expires_at)

	assert result == expected

	expires_at = NaiveDateTime.from_iso8601!(expires_at)
	assert NaiveDateTime.diff(expires_at, NaiveDateTime.utc_now()) in 15..20
	end

	test "detects if it is multiple choice" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Which Mastodon developer is your favourite?",
	poll: %{
	options: ["Gargron", "Eugen"],
	expires_in: 20,
	multiple: true
	}
	})

	voter = insert(:user)

	object = Object.normalize(activity, fetch: false)

	{:ok, _votes, object} = CommonAPI.vote(object, voter, [0, 1])

	assert match?(
	%{
	multiple: true,
	voters_count: 1,
	votes_count: 2
	},
	PollView.render("show.json", %{object: object})
	)
	end

	test "detects emoji" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "What's with the smug face?",
	poll: %{
	options: [":blank: sip", ":blank::blank: sip", ":blank::blank::blank: sip"],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)

	assert %{emojis: [%{shortcode: "blank"}]} = PollView.render("show.json", %{object: object})
	end

	test "detects vote status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Which input devices do you use?",
	poll: %{
	options: ["mouse", "trackball", "trackpoint"],
	multiple: true,
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)

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

	result = PollView.render("show.json", %{object: object, for: other_user})

	assert result[:voted] == true
	assert 1 in result[:own_votes]
	assert 2 in result[:own_votes]
	assert Enum.at(result[:options], 1)[:votes_count] == 1
	assert Enum.at(result[:options], 2)[:votes_count] == 1
	end

	test "does not crash on polls with no end date" do
	object = Object.normalize("https://skippers-bin.com/notes/7x9tmrp97i", fetch: true)
	result = PollView.render("show.json", %{object: object})

	assert result[:expires_at] == nil
	assert result[:expired] == false
	end

	test "doesn't strips HTML tags" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "What's with the smug face?",
	poll: %{
	options: [
	"<input type=\"date\">",
	"<input type=\"date\" >",
	"<input type=\"date\"/>",
	"<input type=\"date\"></input>"
	],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)

	assert %{
	options: [
	%{title: "<input type=\"date\">", votes_count: 0},
	%{title: "<input type=\"date\" >", votes_count: 0},
	%{title: "<input type=\"date\"/>", votes_count: 0},
	%{title: "<input type=\"date\"></input>", votes_count: 0}
	]
	} = PollView.render("show.json", %{object: object})
	end

	test "displays correct voters count" do
	object = Object.normalize("https://friends.grishka.me/posts/54642", fetch: true)
	result = PollView.render("show.json", %{object: object})

	assert result[:voters_count] == 14
	end

	test "detects that poll is non anonymous" do
	object = Object.normalize("https://friends.grishka.me/posts/54642", fetch: true)
	result = PollView.render("show.json", %{object: object})

	assert result[:pleroma][:non_anonymous] == true
	end
	+
	+ test "prefers votersCount over voters list when both are present" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Which flavor?",
	+ poll: %{options: ["chocolate", "vanilla"], expires_in: 20}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ voter = insert(:user)
	+ {:ok, _, object} = CommonAPI.vote(object, voter, [0])
	+
	+ assert object.data["votersCount"] == 1
	+ assert length(object.data["voters"]) == 1
	+
	+ object = %{
	+ object
	+ \| data: Map.put(object.data, "votersCount", 42)
	+ }
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == 42
	+ end
	+
	+ test "falls back to voters list when votersCount is absent" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Which flavor?",
	+ poll: %{options: ["chocolate", "vanilla"], expires_in: 20}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ voter = insert(:user)
	+ {:ok, _, object} = CommonAPI.vote(object, voter, [0])
	+
	+ assert length(object.data["voters"]) == 1
	+
	+ data = Map.delete(object.data, "votersCount")
	+ object = %{object \| data: data}
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == 1
	+ end
	+
	+ test "returns 0 when both votersCount and voters are absent" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Which flavor?",
	+ poll: %{options: ["chocolate", "vanilla"], expires_in: 20}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ data =
	+ object.data
	+ \|> Map.delete("votersCount")
	+ \|> Map.delete("voters")
	+
	+ object = %{object \| data: data}
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == 0
	+ end
	+
	+ test "returns 0 when voters list is empty" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Which flavor?",
	+ poll: %{options: ["chocolate", "vanilla"], expires_in: 20}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ data =
	+ object.data
	+ \|> Map.delete("votersCount")
	+ \|> Map.put("voters", [])
	+
	+ object = %{object \| data: data}
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == 0
	+ end
	+
	+ test "does not inflate votersCount when same voter picks multiple options" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Pick several",
	+ poll: %{options: ["a", "b", "c"], expires_in: 20, multiple: true}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ voter = insert(:user)
	+ {:ok, _, object} = CommonAPI.vote(object, voter, [0, 2])
	+
	+ assert object.data["votersCount"] == 1
	+ assert length(object.data["voters"]) == 1
	+ end
	+
	+ test "preserves votersCount from remote source when existing voter picks another option" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Pick several",
	+ poll: %{options: ["a", "b"], expires_in: 20, multiple: true}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ voter = insert(:user)
	+ {:ok, _, object} = CommonAPI.vote(object, voter, [0, 1])
	+
	+ object = %{object \| data: Map.put(object.data, "votersCount", 14)}
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == 14
	+ end
	+
	+ test "returns 0 when votersCount is explicitly 0" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Pick one",
	+ poll: %{options: ["a", "b"], expires_in: 20}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ object = %{object \| data: Map.put(object.data, "votersCount", 0)}
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == 0
	+ end
	+
	+ test "falls back to voters list when votersCount is nil" do
	+ user = insert(:user)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ status: "Pick one",
	+ poll: %{options: ["a", "b"], expires_in: 20}
	+ })
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ voter = insert(:user)
	+ {:ok, _, object} = CommonAPI.vote(object, voter, [0])
	+
	+ object = %{object \| data: Map.put(object.data, "votersCount", nil)}
	+
	+ result = PollView.render("show.json", %{object: object})
	+
	+ assert result[:voters_count] == length(object.data["voters"])
	+ end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 1:22 AM (20 h, 10 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800855
Default Alt Text: (27 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions