No OneTemporary
Actions

Size

38 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index fcc000969..94462c3dd 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,541 +1,548 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	import Pleroma.Web.Gettext

	alias Calendar.Strftime
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Plugs.AuthenticationPlug
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	require Logger

	# This is a hack for twidere.
	def get_by_id_or_ap_id(id) do
	activity =
	Activity.get_by_id_with_object(id) \|\| Activity.get_create_by_object_ap_id_with_object(id)

	activity &&
	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_by_object_ap_id_with_object(activity.data["object"])
	end
	end

	def get_replied_to_activity(""), do: nil

	def get_replied_to_activity(id) when not is_nil(id) do
	Activity.get_by_id(id)
	end

	def get_replied_to_activity(_), do: nil

	def attachments_from_ids(data) do
	if Map.has_key?(data, "descriptions") do
	attachments_from_ids_descs(data["media_ids"], data["descriptions"])
	else
	attachments_from_ids_no_descs(data["media_ids"])
	end
	end

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids \|\| [], fn media_id ->
	Repo.get(Object, media_id).data
	end)
	end

	def attachments_from_ids_descs(ids, descs_str) do
	{_, descs} = Jason.decode(descs_str)

	Enum.map(ids \|\| [], fn media_id ->
	Map.put(Repo.get(Object, media_id).data, "name", descs[media_id])
	end)
	end

	@spec get_to_and_cc(User.t(), list(String.t()), Activity.t() \| nil, String.t()) ::
	{list(String.t()), list(String.t())}
	def get_to_and_cc(user, mentioned_users, inReplyTo, "public") do
	to = ["https://www.w3.org/ns/activitystreams#Public" \| mentioned_users]
	cc = [user.follower_address]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(user, mentioned_users, inReplyTo, "unlisted") do
	to = [user.follower_address \| mentioned_users]
	cc = ["https://www.w3.org/ns/activitystreams#Public"]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(user, mentioned_users, inReplyTo, "private") do
	{to, cc} = get_to_and_cc(user, mentioned_users, inReplyTo, "direct")
	{[user.follower_address \| to], cc}
	end

	def get_to_and_cc(_user, mentioned_users, inReplyTo, "direct") do
	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def get_to_and_cc(_user, mentions, _inReplyTo, {:list, _}), do: {mentions, []}

	def get_addressed_users(_, to) when is_list(to) do
	User.get_ap_ids_by_nicknames(to)
	end

	def get_addressed_users(mentioned_users, _), do: mentioned_users

	def maybe_add_list_data(activity_params, user, {:list, list_id}) do
	case Pleroma.List.get(list_id, user) do
	%Pleroma.List{} = list ->
	activity_params
	\|> put_in([:additional, "bcc"], [list.ap_id])
	\|> put_in([:additional, "listMessage"], list.ap_id)
	\|> put_in([:object, "listMessage"], list.ap_id)

	_ ->
	activity_params
	end
	end

	def maybe_add_list_data(activity_params, _, _), do: activity_params

	def make_poll_data(%{"poll" => %{"options" => options, "expires_in" => expires_in}} = data)
	when is_list(options) do
	%{max_expiration: max_expiration, min_expiration: min_expiration} =
	limits = Pleroma.Config.get([:instance, :poll_limits])

	# XXX: There is probably a cleaner way of doing this
	try do
	# In some cases mastofe sends out strings instead of integers
	expires_in = if is_binary(expires_in), do: String.to_integer(expires_in), else: expires_in

	if Enum.count(options) > limits.max_options do
	raise ArgumentError, message: "Poll can't contain more than #{limits.max_options} options"
	end

	{poll, emoji} =
	Enum.map_reduce(options, %{}, fn option, emoji ->
	if String.length(option) > limits.max_option_chars do
	raise ArgumentError,
	message:
	"Poll options cannot be longer than #{limits.max_option_chars} characters each"
	end

	{%{
	"name" => option,
	"type" => "Note",
	"replies" => %{"type" => "Collection", "totalItems" => 0}
	}, Map.merge(emoji, Formatter.get_emoji_map(option))}
	end)

	case expires_in do
	expires_in when expires_in > max_expiration ->
	raise ArgumentError, message: "Expiration date is too far in the future"

	expires_in when expires_in < min_expiration ->
	raise ArgumentError, message: "Expiration date is too soon"

	_ ->
	:noop
	end

	end_time =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(expires_in)
	\|> NaiveDateTime.to_iso8601()

	poll =
	if Pleroma.Web.ControllerHelper.truthy_param?(data["poll"]["multiple"]) do
	%{"type" => "Question", "anyOf" => poll, "closed" => end_time}
	else
	%{"type" => "Question", "oneOf" => poll, "closed" => end_time}
	end

	{poll, emoji}
	rescue
	e in ArgumentError -> e.message
	end
	end

	def make_poll_data(%{"poll" => poll}) when is_map(poll) do
	"Invalid poll"
	end

	def make_poll_data(_data) do
	{%{}, %{}}
	end

	def make_content_html(
	status,
	attachments,
	data,
	visibility
	) do
	no_attachment_links =
	data
	\|> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
	\|> Kernel.in([true, "true"])

	content_type = get_content_type(data["content_type"])

	options =
	if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
	[safe_mention: true]
	else
	[]
	end

	status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(attachments, no_attachment_links)
	\|> maybe_add_nsfw_tag(data)
	end

	defp get_content_type(content_type) do
	if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
	when sensitive in [true, "True", "true", "1"] do
	{text, mentions, [{"#nsfw", "nsfw"} \| tags]}
	end

	defp maybe_add_nsfw_tag(data, _), do: data

	def make_context(%Activity{data: %{"context" => context}}), do: context
	def make_context(_), do: Utils.generate_context_id()

	def maybe_add_attachments(parsed, _attachments, true = _no_links), do: parsed

	def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
	text = add_attachments(text, attachments)
	{text, mentions, tags}
	end

	def add_attachments(text, attachments) do
	attachment_text =
	Enum.map(attachments, fn
	%{"url" => [%{"href" => href} \| _]} = attachment ->
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"

	_ ->
	""
	end)

	Enum.join([text \| attachment_text], "<br>")
	end

	def format_input(text, format, options \\ [])

	@doc """
	Formatting text to plain text.
	"""
	def format_input(text, "text/plain", options) do
	text
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()
	end

	@doc """
	Formatting text as BBCode.
	"""
	def format_input(text, "text/bbcode", options) do
	text
	\|> String.replace(~r/\r/, "")
	\|> Formatter.html_escape("text/plain")
	\|> BBCode.to_html()
	\|> (fn {:ok, html} -> html end).()
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to html.
	"""
	def format_input(text, "text/html", options) do
	text
	\|> Formatter.html_escape("text/html")
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to markdown.
	"""
	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Earmark.as_html!()
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	in_reply_to,
	tags,
	cw \\ nil,
	cc \\ [],
	sensitive \\ false,
	merge \\ %{}
	) do
	object = %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => cw,
	"sensitive" => !Enum.member?(["false", "False", "0", false], sensitive),
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => tags \|> Enum.map(fn {_, tag} -> tag end) \|> Enum.uniq()
	}

	object =
	with false <- is_nil(in_reply_to),
	%Object{} = in_reply_to_object <- Object.normalize(in_reply_to) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end

	Map.merge(object, merge)
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) when is_binary(date) do
	with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
	format_asctime(date)
	else
	_e ->
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end
	end

	def date_to_asctime(date) do
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) do
	try do
	date
	\|> NaiveDateTime.from_iso8601!()
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	rescue
	_e -> ""
	end
	end

	defp shortname(name) do
	if String.length(name) < 30 do
	name
	else
	String.slice(name, 0..30) <> "…"
	end
	end

	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
	true <- AuthenticationPlug.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, dgettext("errors", "Invalid password.")}
	end
	end

	def emoji_from_profile(%{info: _info} = user) do
	(Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
	\|> Enum.map(fn {shortcode, url, _} ->
	%{
	"type" => "Emoji",
	"icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
	"name" => ":#{shortcode}:"
	}
	end)
	end

	def maybe_notify_to_recipients(
	recipients,
	%Activity{data: %{"to" => to, "type" => _type}} = _activity
	) do
	recipients ++ to
	end

	def maybe_notify_mentioned_recipients(
	recipients,
	%Activity{data: %{"to" => _to, "type" => type} = data} = activity
	)
	when type == "Create" do
	object = Object.normalize(activity)

	object_data =
	cond do
	!is_nil(object) ->
	object.data

	is_map(data["object"]) ->
	data["object"]

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	+ # Do not notify subscribers if author is making a reply
	+ def maybe_notify_subscribers(recipients, %Activity{
	+ object: %Object{data: %{"inReplyTo" => _ap_id}}
	+ }) do
	+ recipients
	+ end
	+
	def maybe_notify_subscribers(
	recipients,
	%Activity{data: %{"actor" => actor, "type" => type}} = activity
	)
	when type == "Create" do
	with %User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscribers()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

	recipients ++ subscriber_ids
	end
	end

	def maybe_notify_subscribers(recipients, _), do: recipients

	def maybe_extract_mentions(%{"tag" => tag}) do
	tag
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	end

	def maybe_extract_mentions(_), do: []

	def make_report_content_html(nil), do: {:ok, {nil, [], []}}

	def make_report_content_html(comment) do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)

	if String.length(comment) <= max_size do
	{:ok, format_input(comment, "text/plain")}
	else
	{:error,
	dgettext("errors", "Comment must be up to %{max_size} characters", max_size: max_size)}
	end
	end

	def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

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

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, %{id: id}} ->
	id

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context).id
	end
	end
	end

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, dgettext("errors", "No such conversation")}
	end
	end

	def make_answer_data(%User{ap_id: ap_id}, object, name) do
	%{
	"type" => "Answer",
	"actor" => ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"]
	}
	end

	def validate_character_limit(full_payload, attachments, limit) do
	length = String.length(full_payload)

	if length < limit do
	if length > 0 or Enum.count(attachments) > 0 do
	:ok
	else
	{:error, dgettext("errors", "Cannot post an empty status without attachments")}
	end
	else
	{:error, dgettext("errors", "The status is over the character limit")}
	end
	end
	end
	diff --git a/test/notification_test.exs b/test/notification_test.exs
	index dda570b49..28f8df49d 100644
	--- a/test/notification_test.exs
	+++ b/test/notification_test.exs
	@@ -1,640 +1,662 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase
	alias Pleroma.Notification
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	import Pleroma.Factory

	describe "create_notifications" do
	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
	})

	{:ok, [notification, other_notification]} = Notification.create_notifications(activity)

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert other_notification.activity_id == activity.id
	end

	test "it creates a notification for subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification.user_id == subscriber.id
	end
	+
	+ test "does not create a notification for subscribed users if status is a reply" do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+ subscriber = insert(:user)
	+
	+ User.subscribe(subscriber, other_user)
	+
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	+
	+ {:ok, _reply_activity} =
	+ CommonAPI.post(other_user, %{
	+ "status" => "test reply",
	+ "in_reply_to_status_id" => activity.id
	+ })
	+
	+ user_notifications = Notification.for_user(user)
	+ assert length(user_notifications) == 1
	+
	+ subscriber_notifications = Notification.for_user(subscriber)
	+ assert Enum.empty?(subscriber_notifications)
	+ end
	end

	describe "create_notification" do
	setup do
	GenServer.start(Streamer, %{}, name: Streamer)

	on_exit(fn ->
	if pid = Process.whereis(Streamer) do
	Process.exit(pid, :kill)
	end
	end)
	end

	test "it creates a notification for user and send to the 'user' and the 'user:notification' stream" do
	user = insert(:user)
	task = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
	task_user_notification = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
	Streamer.add_socket("user", %{transport_pid: task.pid, assigns: %{user: user}})

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task_user_notification.pid, assigns: %{user: user}}
	)

	activity = insert(:note_activity)

	notify = Notification.create_notification(activity, user)
	assert notify.user_id == user.id
	Task.await(task)
	Task.await(task_user_notification)
	end

	test "it creates a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, user} = User.block(user, author)

	assert Notification.create_notification(activity, user)
	end

	test "it creates a notificatin for the user if the user mutes the activity author" do
	muter = insert(:user)
	muted = insert(:user)
	{:ok, _} = User.mute(muter, muted)
	muter = Repo.get(User, muter.id)
	{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})

	assert Notification.create_notification(activity, muter)
	end

	test "notification created if user is muted without notifications" do
	muter = insert(:user)
	muted = insert(:user)

	{:ok, muter} = User.mute(muter, muted, false)

	{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})

	assert Notification.create_notification(activity, muter)
	end

	test "it creates a notification for an activity from a muted thread" do
	muter = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(muter, %{"status" => "hey"})
	CommonAPI.add_mute(muter, activity)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	"status" => "Hi @#{muter.nickname}",
	"in_reply_to_status_id" => activity.id
	})

	assert Notification.create_notification(activity, muter)
	end

	test "it disables notifications from followers" do
	follower = insert(:user)
	followed = insert(:user, info: %{notification_settings: %{"followers" => false}})
	User.follow(follower, followed)
	{:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from non-followers" do
	follower = insert(:user)
	followed = insert(:user, info: %{notification_settings: %{"non_followers" => false}})
	{:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from people the user follows" do
	follower = insert(:user, info: %{notification_settings: %{"follows" => false}})
	followed = insert(:user)
	User.follow(follower, followed)
	follower = Repo.get(User, follower.id)
	{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	refute Notification.create_notification(activity, follower)
	end

	test "it disables notifications from people the user does not follow" do
	follower = insert(:user, info: %{notification_settings: %{"non_follows" => false}})
	followed = insert(:user)
	{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	refute Notification.create_notification(activity, follower)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	refute Notification.create_notification(activity, author)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user)
	{:ok, _, _, activity} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
	Notification.create_notification(activity, followed_user)
	TwitterAPI.unfollow(user, %{"user_id" => followed_user.id})
	{:ok, _, _, activity_dupe} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
	refute Notification.create_notification(activity_dupe, followed_user)
	end

	test "it doesn't create a notification for like-unlike-like chains" do
	user = insert(:user)
	liked_user = insert(:user)
	{:ok, status} = TwitterAPI.create_status(liked_user, %{"status" => "Yui is best yuru"})
	{:ok, fav_status} = TwitterAPI.fav(user, status.id)
	Notification.create_notification(fav_status, liked_user)
	TwitterAPI.unfav(user, status.id)
	{:ok, dupe} = TwitterAPI.fav(user, status.id)
	refute Notification.create_notification(dupe, liked_user)
	end

	test "it doesn't create a notification for repeat-unrepeat-repeat chains" do
	user = insert(:user)
	retweeted_user = insert(:user)

	{:ok, status} =
	TwitterAPI.create_status(retweeted_user, %{
	"status" => "Send dupe notifications to the shadow realm"
	})

	{:ok, retweeted_activity} = TwitterAPI.repeat(user, status.id)
	Notification.create_notification(retweeted_activity, retweeted_user)
	TwitterAPI.unrepeat(user, status.id)
	{:ok, dupe} = TwitterAPI.repeat(user, status.id)
	refute Notification.create_notification(dupe, retweeted_user)
	end

	test "it doesn't create duplicate notifications for follow+subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	{:ok, _, _, _} = TwitterAPI.follow(subscriber, %{"user_id" => user.id})
	User.subscribe(subscriber, user)
	{:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
	{:ok, [_notif]} = Notification.create_notifications(status)
	end

	test "it doesn't create subscription notifications if the recipient cannot see the status" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} =
	TwitterAPI.create_status(user, %{"status" => "inwisible", "visibility" => "direct"})

	assert {:ok, []} == Notification.create_notifications(status)
	end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.get(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.dismiss(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = notifs = Notification.for_user(other_user)
	assert length(notifs) == 2

	assert n2.id > n1.id

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey yet again @#{other_user.nickname}!"
	})

	Notification.set_read_up_to(other_user, n2.id)

	[n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false
	end
	end

	describe "notification target determination" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user not in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

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

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _, _} = CommonAPI.unfavorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert length(Notification.for_user(user)) == 1

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

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _} = CommonAPI.unrepeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.favorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "replying to a deleted post without tagging does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	"status" => "test reply",
	"in_reply_to_status_id" => activity.id
	})

	assert Enum.empty?(Notification.for_user(user))
	end
	end

	describe "for_user" do
	test "it returns notifications for muted user without notifications" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, user} = User.mute(user, muted, false)

	{:ok, _activity} = TwitterAPI.create_status(muted, %{"status" => "hey @#{user.nickname}"})

	assert length(Notification.for_user(user)) == 1
	end

	test "it doesn't return notifications for muted user with notifications" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, user} = User.mute(user, muted)

	{:ok, _activity} = TwitterAPI.create_status(muted, %{"status" => "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for blocked user" do
	user = insert(:user)
	blocked = insert(:user)
	{:ok, user} = User.block(user, blocked)

	{:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notificatitons for blocked domain" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	{:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for muted thread" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(another_user, %{"status" => "hey @#{user.nickname}"})

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert Notification.for_user(user) == []
	end

	test "it returns notifications for muted user with notifications and with_muted parameter" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, user} = User.mute(user, muted)

	{:ok, _activity} = TwitterAPI.create_status(muted, %{"status" => "hey @#{user.nickname}"})

	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it returns notifications for blocked user and with_muted parameter" do
	user = insert(:user)
	blocked = insert(:user)
	{:ok, user} = User.block(user, blocked)

	{:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})

	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it returns notificatitons for blocked domain and with_muted parameter" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	{:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})

	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it returns notifications for muted thread with_muted parameter" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(another_user, %{"status" => "hey @#{user.nickname}"})

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 1:11 AM (18 h, 18 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768583
Default Alt Text: (38 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions