No OneTemporary
Actions

Authored By

Unknown

Size

51 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index 32ee6a296..59df4d20a 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,314 +1,318 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Formatter do
	require Logger

	alias Pleroma.HTML
	alias Pleroma.User

	@safe_mention_regex ~r/^(\s(?<mentions>(@.+?\s+){1,})+)(?<rest>.)/s
	@link_regex ~r"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\\+,;=.]+)\|[0-9a-z+\-\.]+:[0-9a-z$-_.+!'(),]+"ui
	@markdown_characters_regex ~r/(`\|\*\|_\|{\|}\|[\|]\|$\|$\|#\|\+\|-\|\.\|!)/
	@markdown_void_elements ~w[area base br col command embed hr img input keygen link meta param source track wbr]

	defp linkify_opts do
	Pleroma.Config.get(Pleroma.Formatter) ++
	[
	hashtag: true,
	hashtag_handler: &Pleroma.Formatter.hashtag_handler/4,
	mention: true,
	mention_handler: &Pleroma.Formatter.mention_handler/4
	]
	end

	def escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
	case User.get_cached_by_nickname(nickname) do
	%User{} ->
	# escape markdown characters with `\\`
	# (we don't want something like @user__name to be parsed by markdown)
	String.replace(mention, @markdown_characters_regex, "\\\\\\1")

	_ ->
	buffer
	end
	end

	def mention_handler("@" <> nickname, buffer, opts, acc) do
	case User.get_cached_by_nickname(nickname) do
	%User{} = user ->
	{mention_from_user(user, opts),
	%{acc \| mentions: MapSet.put(acc.mentions, {"@" <> nickname, user})}}

	_ ->
	{buffer, acc}
	end
	end

	def mention_from_user(%User{id: id} = user, opts \\ %{mentions_format: :full}) do
	user_url = user.uri \|\| user.ap_id
	nickname_text = get_nickname_text(user.nickname, opts)

	Phoenix.HTML.Tag.content_tag(
	:span,
	Phoenix.HTML.Tag.content_tag(
	:a,
	["@", Phoenix.HTML.Tag.content_tag(:span, nickname_text)],
	"data-user": id,
	class: "u-url mention",
	href: user_url,
	rel: "ugc"
	),
	class: "h-card"
	)
	\|> Phoenix.HTML.safe_to_string()
	end

	def hashtag_handler("#" <> tag = tag_text, _buffer, _opts, acc) do
	tag = String.downcase(tag)
	url = "#{Pleroma.Web.Endpoint.url()}/tag/#{tag}"

	link =
	Phoenix.HTML.Tag.content_tag(:a, tag_text,
	class: "hashtag",
	"data-tag": tag,
	href: url,
	rel: "tag ugc"
	)
	\|> Phoenix.HTML.safe_to_string()

	{link, %{acc \| tags: MapSet.put(acc.tags, {tag_text, tag})}}
	end

	@doc """
	Parses a text and replace plain text links with HTML. Returns a tuple with a result text, mentions, and hashtags.

	If the 'safe_mention' option is given, only consecutive mentions at the start the post are actually mentioned.
	"""
	@spec linkify(String.t(), keyword()) ::
	{String.t(), [{String.t(), User.t()}], [{String.t(), String.t()}]}
	def linkify(text, options \\ []) do
	options = linkify_opts() ++ options

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}

	{text_mentions, %{mentions: mentions}} = Linkify.link_map(mentions, acc, options)
	{text_rest, %{tags: tags}} = Linkify.link_map(rest, acc, options)

	{text_mentions <> text_rest, MapSet.to_list(mentions), MapSet.to_list(tags)}
	else
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}
	{text, %{mentions: mentions, tags: tags}} = Linkify.link_map(text, acc, options)

	{text, MapSet.to_list(mentions), MapSet.to_list(tags)}
	end
	end

	@doc """
	Escapes a special characters in mention names.
	"""
	def mentions_escape(text, options \\ []) do
	options =
	Keyword.merge(options,
	mention: true,
	url: false,
	mention_handler: &Pleroma.Formatter.escape_mention_handler/4
	)

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	Linkify.link(mentions, options) <> Linkify.link(rest, options)
	else
	Linkify.link(text, options)
	end
	end

	def markdown_to_html(text) do
	markdown_to_html(text, %{})
	end

	def markdown_to_html(text, opts) do
	breaks = Map.get(opts, :breaks, false)

	{_status, ast, _messages} = EarmarkParser.as_ast(text, breaks: breaks, gfm: true)

	ast
	\|> maybe_strip_email_autolinks(text, Map.get(opts, :strip_email_autolinks, false))
	\|> render_markdown_nodes(false)
	\|> IO.iodata_to_binary()
	rescue
	exception ->
	Logger.warning("Markdown rendering failed in #{inspect(exception.__struct__)}")
	markdown_fallback(text, Map.get(opts, :breaks, false))
	end

	defp markdown_fallback(text, breaks) do
	text = text \|> escape_html() \|> IO.iodata_to_binary() \|> maybe_render_markdown_breaks(breaks)
	"<p>" <> text <> "</p>"
	end

	defp maybe_render_markdown_breaks(text, true), do: String.replace(text, ~r/\r?\n/, "<br>")
	defp maybe_render_markdown_breaks(text, false), do: text

	defp maybe_strip_email_autolinks(ast, _text, false), do: ast

	defp maybe_strip_email_autolinks(ast, text, true) do
	emails =
	~r/<([^ >]+@[^ >]+)>/
	\|> Regex.scan(text, capture: :all_but_first)
	\|> Enum.map(fn [email] -> String.replace_prefix(email, "mailto:", "") end)
	\|> MapSet.new()

	strip_email_autolinks(ast, emails)
	end

	defp strip_email_autolinks(nodes, emails) when is_list(nodes) do
	Enum.map(nodes, &strip_email_autolinks(&1, emails))
	end

	defp strip_email_autolinks({"a", attrs, [email], _meta} = node, emails)
	when is_binary(email) do
	if List.keyfind(attrs, "href", 0) == {"href", "mailto:" <> email} and
	MapSet.member?(emails, email) do
	email
	else
	node
	end
	end

	defp strip_email_autolinks({tag, attrs, children, meta}, emails) do
	{tag, attrs, strip_email_autolinks(children, emails), meta}
	end

	defp strip_email_autolinks(text, _emails) when is_binary(text), do: text

	defp render_markdown_nodes(nodes, verbatim) when is_list(nodes) do
	Enum.map(nodes, &render_markdown_node(&1, verbatim))
	end

	defp render_markdown_node(text, true) when is_binary(text),
	do: strip_dangerous_markdown_html(text)

	defp render_markdown_node(text, false) when is_binary(text) do
	text
	\|> strip_dangerous_markdown_html()
	\|> escape_markdown_html()
	end

	defp render_markdown_node({:comment, _attrs, _children, _meta}, _verbatim), do: []

	defp render_markdown_node({tag, attrs, children, meta}, verbatim) do
	normalized_tag = String.downcase(tag)

	if normalized_tag in ["script", "style"] do
	[]
	else
	render_markdown_element(tag, normalized_tag, attrs, children, meta, verbatim)
	end
	end

	defp render_markdown_element("code", _normalized_tag, attrs, children, _meta, _verbatim) do
	["<code", render_markdown_attrs(attrs), ">", render_markdown_code(children), "</code>"]
	end

	defp render_markdown_element(tag, "hr", attrs, _children, _meta, _verbatim) do
	attrs = Enum.reject(attrs, &match?({"class", class} when class in ~w[thin medium thick], &1))
	["<", tag, render_markdown_attrs(attrs), "/>"]
	end

	defp render_markdown_element(tag, normalized_tag, attrs, _children, _meta, _verbatim)
	when normalized_tag in @markdown_void_elements do
	["<", tag, render_markdown_attrs(attrs), ">"]
	end

	defp render_markdown_element(tag, _normalized_tag, attrs, children, meta, verbatim) do
	children_verbatim = verbatim or Map.get(meta, :verbatim, false)

	[
	"<",
	tag,
	render_markdown_attrs(attrs),
	">",
	render_markdown_nodes(children, children_verbatim),
	"</",
	tag,
	">"
	]
	end

	defp render_markdown_attrs(attrs) do
	Enum.map(attrs, fn {name, value} ->
	value = value \|> to_string() \|> HtmlEntities.decode() \|> sanitize_markdown_url(name)
	[" ", to_string(name), "=\"", escape_html(value), "\""]
	end)
	end

	defp render_markdown_code(children) do
	Enum.map(children, &escape_html/1)
	end

	defp sanitize_markdown_url(value, name) do
	if String.downcase(to_string(name)) in ["href", "src"] do
	- value
	- \|> String.split(~r/["<>]/, parts: 2)
	- \|> hd()
	+ # Percent-encode instead of cutting, so the URL stays complete but can
	+ # never close the attribute or open a tag.
	+ String.replace(value, ~r/["<>]/, fn
	+ "\"" -> "%22"
	+ "<" -> "%3C"
	+ ">" -> "%3E"
	+ end)
	else
	value
	end
	end

	defp strip_dangerous_markdown_html(text) do
	text
	\|> String.replace(~r/<(script\|style)\b[^>]>.?<\/\1>/is, "")
	\|> String.replace(~r/<(script\|style)\b[^>]>.\z/is, "")
	\|> String.replace(~r/<\/(script\|style)\s*>/i, "")
	end

	defp escape_markdown_html(text) do
	text \|> HtmlEntities.decode() \|> escape_html()
	end

	defp escape_html(text) do
	{:safe, escaped} = Phoenix.HTML.html_escape(text)
	escaped
	end

	def html_escape({text, mentions, hashtags}, type) do
	{html_escape(text, type), mentions, hashtags}
	end

	def html_escape(text, "text/html") do
	HTML.filter_tags(text)
	end

	def html_escape(text, "text/x.misskeymarkdown") do
	HTML.filter_tags(text)
	end

	def html_escape(text, "text/plain") do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	def truncate(text, max_length \\ 200, omission \\ "...") do
	# Remove trailing whitespace
	text = Regex.replace(~r/([^ \t\r\n])([ \t]+$)/u, text, "\\g{1}")

	if String.length(text) < max_length do
	text
	else
	length_with_omission = max_length - String.length(omission)
	String.slice(text, 0, length_with_omission) <> omission
	end
	end

	defp get_nickname_text(nickname, %{mentions_format: :full}), do: User.full_nickname(nickname)
	defp get_nickname_text(nickname, _), do: User.local_nickname(nickname)
	end
	diff --git a/test/pleroma/formatter_test.exs b/test/pleroma/formatter_test.exs
	index 906d39e4f..2954e526f 100644
	--- a/test/pleroma/formatter_test.exs
	+++ b/test/pleroma/formatter_test.exs
	@@ -1,467 +1,471 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FormatterTest do
	alias Pleroma.Formatter
	alias Pleroma.User
	use Pleroma.DataCase

	import Mock
	import Pleroma.Factory

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

	describe ".add_hashtag_links" do
	test "turns hashtags into links" do
	text = "I love #cofe and #2hu"

	expected_text =
	~s(I love <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe" rel="tag ugc">#cofe</a> and <a class="hashtag" data-tag="2hu" href="http://localhost:4001/tag/2hu" rel="tag ugc">#2hu</a>)

	assert {^expected_text, [], _tags} = Formatter.linkify(text)
	end

	test "does not turn html characters to tags" do
	text = "#fact_3: pleroma does what mastodon't"

	expected_text =
	~s(<a class="hashtag" data-tag="fact_3" href="http://localhost:4001/tag/fact_3" rel="tag ugc">#fact_3</a>: pleroma does what mastodon't)

	assert {^expected_text, [], _tags} = Formatter.linkify(text)
	end
	end

	describe ".add_links" do
	test "turning urls into links" do
	text = "Hey, check out https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla ."

	expected =
	~S(Hey, check out <a href="https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla" rel="ugc">https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla</a> .)

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://mastodon.social/@lambadalambda"

	expected =
	~S(<a href="https://mastodon.social/@lambadalambda" rel="ugc">https://mastodon.social/@lambadalambda</a>)

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://mastodon.social:4000/@lambadalambda"

	expected =
	~S(<a href="https://mastodon.social:4000/@lambadalambda" rel="ugc">https://mastodon.social:4000/@lambadalambda</a>)

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "@lambadalambda"
	expected = "@lambadalambda"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "http://www.cs.vu.nl/~ast/intel/"

	expected =
	~S(<a href="http://www.cs.vu.nl/~ast/intel/" rel="ugc">http://www.cs.vu.nl/~ast/intel/</a>)

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://forum.zdoom.org/viewtopic.php?f=44&t=57087"

	expected =
	"<a href=\"https://forum.zdoom.org/viewtopic.php?f=44&t=57087\" rel=\"ugc\">https://forum.zdoom.org/viewtopic.php?f=44&t=57087</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul\" rel=\"ugc\">https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://www.google.co.jp/search?q=Nasim+Aghdam"

	expected =
	"<a href=\"https://www.google.co.jp/search?q=Nasim+Aghdam\" rel=\"ugc\">https://www.google.co.jp/search?q=Nasim+Aghdam</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://en.wikipedia.org/wiki/Duff's_device"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Duff's_device\" rel=\"ugc\">https://en.wikipedia.org/wiki/Duff's_device</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://pleroma.com https://pleroma.com/sucks"

	expected =
	"<a href=\"https://pleroma.com\" rel=\"ugc\">https://pleroma.com</a> <a href=\"https://pleroma.com/sucks\" rel=\"ugc\">https://pleroma.com/sucks</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "xmpp:contact@hacktivis.me"

	expected = "<a href=\"xmpp:contact@hacktivis.me\" rel=\"ugc\">xmpp:contact@hacktivis.me</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text =
	"magnet:?xt=urn:btih:7ec9d298e91d6e4394d1379caf073c77ff3e3136&tr=udp%3A%2F%2Fopentor.org%3A2710&tr=udp%3A%2F%2Ftracker.blackunicorn.xyz%3A6969&tr=udp%3A%2F%2Ftracker.ccc.de%3A80&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969&tr=udp%3A%2F%2Ftracker.openbittorrent.com%3A80&tr=wss%3A%2F%2Ftracker.btorrent.xyz&tr=wss%3A%2F%2Ftracker.fastcast.nz&tr=wss%3A%2F%2Ftracker.openwebtorrent.com"

	expected = "<a href=\"#{text}\" rel=\"ugc\">#{text}</a>"

	assert {^expected, [], []} = Formatter.linkify(text)
	end
	end

	describe "Formatter.linkify" do
	test "correctly finds mentions that contain the domain name" do
	_user = insert(:user, %{nickname: "lain"})
	_remote_user = insert(:user, %{nickname: "lain@lain.com", local: false})

	text = "hey @lain@lain.com what's up"

	{_text, mentions, []} = Formatter.linkify(text)
	[{username, user}] = mentions

	assert username == "@lain@lain.com"
	assert user.nickname == "lain@lain.com"
	end

	test "gives a replacement for user links, using local nicknames in user links text" do
	text = "@gsimg According to @archa_eme_, that is @daggsy. Also hello @archaeme@archae.me"
	gsimg = insert(:user, %{nickname: "gsimg"})

	archaeme =
	insert(:user,
	nickname: "archa_eme_",
	uri: "https://archeme/@archa_eme_"
	)

	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 3

	expected_text =
	~s(<span class="h-card"><a class="u-url mention" data-user="#{gsimg.id}" href="#{gsimg.ap_id}" rel="ugc">@<span>gsimg</span></a></span> According to <span class="h-card"><a class="u-url mention" data-user="#{archaeme.id}" href="#{"https://archeme/@archa_eme_"}" rel="ugc">@<span>archa_eme_</span></a></span>, that is @daggsy. Also hello <span class="h-card"><a class="u-url mention" data-user="#{archaeme_remote.id}" href="#{archaeme_remote.ap_id}" rel="ugc">@<span>archaeme</span></a></span>)

	assert expected_text == text
	end

	test "gives a replacement for user links when the user is using Osada" do
	{:ok, mike} = User.get_or_fetch("mike@osada.macgirvin.com")

	text = "@mike@osada.macgirvin.com test"

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	~s(<span class="h-card"><a class="u-url mention" data-user="#{mike.id}" href="#{mike.ap_id}" rel="ugc">@<span>mike</span></a></span> test)

	assert expected_text == text
	end

	test "gives a replacement for single-character local nicknames" do
	text = "@o hi"
	o = insert(:user, %{nickname: "o"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	~s(<span class="h-card"><a class="u-url mention" data-user="#{o.id}" href="#{o.ap_id}" rel="ugc">@<span>o</span></a></span> hi)

	assert expected_text == text
	end

	test "does not give a replacement for single-character local nicknames who don't exist" do
	text = "@a hi"

	expected_text = "@a hi"
	assert {^expected_text, [] = _mentions, [] = _tags} = Formatter.linkify(text)
	end

	test "given the 'safe_mention' option, it will only mention people in the beginning" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	text = " @#{user.nickname} @#{other_user.nickname} hey dudes i hate @#{third_user.nickname}"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	assert mentions == [{"@#{user.nickname}", user}, {"@#{other_user.nickname}", other_user}]

	assert expected_text ==
	~s(<span class="h-card"><a class="u-url mention" data-user="#{user.id}" href="#{user.ap_id}" rel="ugc">@<span>#{user.nickname}</span></a></span> <span class="h-card"><a class="u-url mention" data-user="#{other_user.id}" href="#{other_user.ap_id}" rel="ugc">@<span>#{other_user.nickname}</span></a></span> hey dudes i hate <span class="h-card"><a class="u-url mention" data-user="#{third_user.id}" href="#{third_user.ap_id}" rel="ugc">@<span>#{third_user.nickname}</span></a></span>)
	end

	test "given the 'safe_mention' option, it will still work without any mention" do
	text = "A post without any mention"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	assert mentions == []
	assert expected_text == text
	end

	test "given the 'safe_mention' option, it will keep text after newlines" do
	user = insert(:user)
	text = " @#{user.nickname}\n hey dude\n\nhow are you doing?"

	{expected_text, _, _} = Formatter.linkify(text, safe_mention: true)

	assert expected_text =~ "how are you doing?"
	end

	test "it can parse mentions and return the relevant users" do
	text =
	"@@gsimg According to @archaeme, that is @daggsy. Also hello @archaeme@archae.me and @o and @@@jimm"

	o = insert(:user, %{nickname: "o"})
	_jimm = insert(:user, %{nickname: "jimm"})
	_gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})
	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	expected_mentions = [
	{"@archaeme", archaeme},
	{"@archaeme@archae.me", archaeme_remote},
	{"@o", o}
	]

	assert {_text, ^expected_mentions, []} = Formatter.linkify(text)
	end

	test "it parses URL containing local mention" do
	_user = insert(:user, %{nickname: "lain"})

	text = "https://example.com/@lain"

	expected = ~S(<a href="https://example.com/@lain" rel="ugc">https://example.com/@lain</a>)

	assert {^expected, [], []} = Formatter.linkify(text)
	end

	test "it correctly parses angry face D:< with mention" do
	lain =
	insert(:user, %{
	nickname: "lain@lain.com",
	ap_id: "https://lain.com/users/lain",
	id: "9qrWmR0cKniB0YU0TA"
	})

	text = "@lain@lain.com D:<"

	expected_text =
	~S(<span class="h-card"><a class="u-url mention" data-user="9qrWmR0cKniB0YU0TA" href="https://lain.com/users/lain" rel="ugc">@<span>lain</span></a></span> D:<)

	expected_mentions = [
	{"@lain@lain.com", lain}
	]

	assert {^expected_text, ^expected_mentions, []} = Formatter.linkify(text)
	end

	test "correctly parses mentions in html" do
	text = "<p>@lain hello</p>"
	lain = insert(:user, %{nickname: "lain"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	~s(<p><span class="h-card"><a class="u-url mention" data-user="#{lain.id}" href="#{lain.ap_id}" rel="ugc">@<span>lain</span></a></span> hello</p>)

	assert expected_text == text
	end

	test "correctly parses mentions on the last line of html" do
	text = "<p>Hello</p><p>@lain</p>"
	lain = insert(:user, %{nickname: "lain"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	~s(<p>Hello</p><p><span class="h-card"><a class="u-url mention" data-user="#{lain.id}" href="#{lain.ap_id}" rel="ugc">@<span>lain</span></a></span></p>)

	assert expected_text == text
	end
	end

	describe ".parse_tags" do
	test "parses tags in the text" do
	text = "Here's a #Test. Maybe these are #working or not. What about #漢字? And #は｡"

	expected_tags = [
	{"#Test", "test"},
	{"#working", "working"},
	{"#は", "は"},
	{"#漢字", "漢字"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end

	test "parses tags in html" do
	text = "<p>This is a #test</p>"

	expected_tags = [
	{"#test", "test"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end

	test "parses multiple tags in html" do
	text = "<p>#tag1 #tag2 #tag3 #tag4</p>"

	expected_tags = [
	{"#tag1", "tag1"},
	{"#tag2", "tag2"},
	{"#tag3", "tag3"},
	{"#tag4", "tag4"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end

	test "parses tags on the last line of html" do
	text = "<p>This is a</p><p>#test</p>"

	expected_tags = [
	{"#test", "test"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end

	test "parses multiple tags on multiple lines in html" do
	text =
	"<p>testing...</p><p>#tag1 #tag2 #tag3 #tag4</p><p>paragraph</p><p>#tag5 #tag6 #tag7 #tag8</p>"

	expected_tags = [
	{"#tag1", "tag1"},
	{"#tag2", "tag2"},
	{"#tag3", "tag3"},
	{"#tag4", "tag4"},
	{"#tag5", "tag5"},
	{"#tag6", "tag6"},
	{"#tag7", "tag7"},
	{"#tag8", "tag8"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end
	end

	test "it escapes HTML in plain text" do
	text = "hello & world google.com/?a=b&c=d \n http://test.com/?a=b&c=d 1"
	expected = "hello & world google.com/?a=b&c=d \n http://test.com/?a=b&c=d 1"

	assert Formatter.html_escape(text, "text/plain") == expected
	end

	describe "markdown_to_html/2" do
	test "keeps formatted link text when stripping email autolinks" do
	opts = %{breaks: true, strip_email_autolinks: true}

	assert Formatter.markdown_to_html("[hello](https://example.org/)", opts) ==
	~s(<p><a href="https://example.org/"><strong>hello</strong></a></p>)

	assert Formatter.markdown_to_html("[`code`](https://example.org/)", opts) ==
	~s(<p><a href="https://example.org/"><code class="inline">code</code></a></p>)
	end

	test "escapes link attribute values" do
	markdown = ~s\|[click](http://example.com/?a=x" onerror="alert(1))\|

	- html = Formatter.markdown_to_html(markdown)
	-
	- assert html =~ ~s\|href="http://example.com/?a=x"\|
	- refute html =~ "onerror"
	+ # The quotes are percent-encoded, so everything stays inside href.
	+ assert Formatter.markdown_to_html(markdown) ==
	+ ~s\|<p><a href="http://example.com/?a=x%22 onerror=%22alert(1)">click</a></p>\|
	end

	test "preserves entities without rendering dangerous raw HTML" do
	markdown = "safe & sound<script>alert(1)</script>"

	assert Formatter.markdown_to_html(markdown) == "<p>safe & sound</p>"

	assert Formatter.markdown_to_html("<div><script>alert(1)</script>safe</div>") ==
	"<div>safe</div>"

	assert Formatter.markdown_to_html("<ScRiPt>alert(1)</ScRiPt>") == ""
	assert Formatter.markdown_to_html("<BR>") == "<BR>"
	end

	test "escapes dangerous HTML inside code" do
	markdown = "`<script>&</script>`"

	assert Formatter.markdown_to_html(markdown) ==
	~s(<p><code class="inline"><script>&amp;</script></code></p>)
	end

	test "rejects entity-encoded URL delimiters" do
	markdown = "[click](http://example.com/?a=x"onerror=alert(1))"

	- html = Formatter.markdown_to_html(markdown)
	+ assert Formatter.markdown_to_html(markdown) ==
	+ ~s\|<p><a href="http://example.com/?a=x%22onerror=alert(1)">click</a></p>\|
	+ end
	+
	+ test "keeps URLs with encoded quotes complete" do
	+ markdown = "[search](https://example.org/?q="cat"&page=2)"

	- assert html =~ ~s\|href="http://example.com/?a=x"\|
	- refute html =~ "onerror"
	+ assert Formatter.markdown_to_html(markdown) ==
	+ ~s(<p><a href="https://example.org/?q=%22cat%22&page=2">search</a></p>)
	end

	test "strips email autolinks without changing explicit mailto links" do
	opts = %{strip_email_autolinks: true}

	assert Formatter.markdown_to_html("<foo@example.com>", opts) ==
	"<p>foo@example.com</p>"

	assert Formatter.markdown_to_html("[email](mailto:foo@example.com)", opts) ==
	~s(<p><a href="mailto:foo@example.com">email</a></p>)
	end

	test "handles malformed Markdown that crashed older EarmarkParser releases" do
	assert Formatter.markdown_to_html("\\[{:}") == "<p>[{:}</p>"
	end

	test "handles a malformed Markdown regression corpus" do
	markdown_samples = [
	"- hello\n{:.claass .klass}",
	"[link](\"",
	"<script",
	"</style>",
	"~~~",
	"<![CDATA[",
	<<0>>
	]

	for markdown <- markdown_samples do
	html = Formatter.markdown_to_html(markdown)

	assert is_binary(html)
	refute html =~ <<0>>
	end
	end

	test "falls back to escaped text when parsing fails" do
	markdown = "<script>alert(1)</script>\nnext"

	with_mock EarmarkParser, as_ast: fn _text, _opts -> raise "parser failed" end do
	assert Formatter.markdown_to_html(markdown, %{breaks: true}) ==
	"<p><script>alert(1)</script><br>next</p>"
	end
	end
	end
	end
	diff --git a/test/pleroma/web/common_api/utils_test.exs b/test/pleroma/web/common_api/utils_test.exs
	index ff5150c40..44a7486de 100644
	--- a/test/pleroma/web/common_api/utils_test.exs
	+++ b/test/pleroma/web/common_api/utils_test.exs
	@@ -1,708 +1,708 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.UtilsTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.ActivityDraft
	alias Pleroma.Web.CommonAPI.Utils
	use Pleroma.DataCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	@public_address "https://www.w3.org/ns/activitystreams#Public"

	describe "add_attachments/2" do
	setup do
	name =
	"Sakura Mana – Turned on by a Senior OL with a Temptating Tight Skirt-s Full Hipline and Panty Shot- Beautiful Thick Thighs- and Erotic Ass- -2015- -- Oppaitime 8-28-2017 6-50-33 PM.png"

	attachment = %{
	"url" => [%{"href" => URI.encode(name)}]
	}

	%{name: name, attachment: attachment}
	end

	test "it adds attachment links to a given text and attachment set", %{
	name: name,
	attachment: attachment
	} do
	len = 10
	clear_config([Pleroma.Upload, :filename_display_max_length], len)

	expected =
	"<br><a href=\"#{URI.encode(name)}\" class='attachment'>#{String.slice(name, 0..len)}…</a>"

	assert Utils.add_attachments("", [attachment]) == expected
	end

	test "doesn't truncate file name if config for truncate is set to 0", %{
	name: name,
	attachment: attachment
	} do
	clear_config([Pleroma.Upload, :filename_display_max_length], 0)

	expected = "<br><a href=\"#{URI.encode(name)}\" class='attachment'>#{name}</a>"

	assert Utils.add_attachments("", [attachment]) == expected
	end
	end

	describe "it confirms the password given is the current users password" do
	test "incorrect password given" do
	{:ok, user} = UserBuilder.insert()

	assert Utils.confirm_current_password(user, "") == {:error, "Invalid password."}
	end

	test "correct password given" do
	{:ok, user} = UserBuilder.insert()
	assert Utils.confirm_current_password(user, "test") == {:ok, user}
	end
	end

	describe "format_input/3" do
	test "works for bare text/plain" do
	text = "hello world!"
	expected = "hello world!"

	{output, [], []} = Utils.format_input(text, "text/plain")

	assert output == expected

	text = "hello world!\n\nsecond paragraph!"
	expected = "hello world!<br><br>second paragraph!"

	{output, [], []} = Utils.format_input(text, "text/plain")

	assert output == expected
	end

	test "works for bare text/html" do
	text = "<p>hello world!</p>"
	expected = "<p>hello world!</p>"

	{output, [], []} = Utils.format_input(text, "text/html")

	assert output == expected

	text = "<p>hello world!</p><br/>\n<p>second paragraph</p>"
	expected = "<p>hello world!</p><br/>\n<p>second paragraph</p>"

	{output, [], []} = Utils.format_input(text, "text/html")

	assert output == expected
	end

	test "works for bare text/markdown" do
	text = "hello world"
	expected = "<p><strong>hello world</strong></p>"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected

	text = "hello world\n\nanother paragraph"
	expected = "<p><strong>hello world</strong></p><p><em>another paragraph</em></p>"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected

	text = """
	> cool quote

	by someone
	"""

	expected = "<blockquote><p>cool quote</p></blockquote><p>by someone</p>"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected
	end

	test "MFM keeps bare URLs containing Markdown delimiters intact" do
	url = "https://example.org/abc"

	{output, [], []} = Utils.format_input(url, "text/x.misskeymarkdown")

	assert output == ~s(<p><a href="#{url}">#{url}</a></p>)
	end

	test "works for bare text/bbcode" do
	text = "[b]hello world[/b]"
	expected = "<strong>hello world</strong>"

	{output, [], []} = Utils.format_input(text, "text/bbcode")

	assert output == expected

	text = "[b]hello world![/b]\n\nsecond paragraph!"
	expected = "<strong>hello world!</strong><br><br>second paragraph!"

	{output, [], []} = Utils.format_input(text, "text/bbcode")

	assert output == expected

	text = "[b]hello world![/b]\n\n<strong>second paragraph!</strong>"

	expected =
	"<strong>hello world!</strong><br><br><strong>second paragraph!</strong>"

	{output, [], []} = Utils.format_input(text, "text/bbcode")

	assert output == expected
	end

	test "works for text/markdown with mentions" do
	{:ok, user} =
	UserBuilder.insert(%{nickname: "user__test", ap_id: "http://foo.com/user__test"})

	text = "hello world\n\nanother @user__test and @user__test google.com paragraph"

	{output, _, _} = Utils.format_input(text, "text/markdown")

	assert output ==
	~s(<p><strong>hello world</strong></p><p><em>another <span class="h-card"><a class="u-url mention" data-user="#{user.id}" href="http://foo.com/user__test" rel="ugc">@<span>user__test</span></a></span> and <span class="h-card"><a class="u-url mention" data-user="#{user.id}" href="http://foo.com/user__test" rel="ugc">@<span>user__test</span></a></span> <a href="http://google.com" rel="ugc">google.com</a> paragraph</em></p>)
	end
	end

	describe "format_input/3 with markdown" do
	test "Paragraph" do
	code = ~s[Hello\n\nWorld!]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<p>Hello</p><p>World!</p>"
	end

	test "links" do
	code = "https://en.wikipedia.org/wiki/Animal_Crossing_(video_game)"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]

	code = "https://github.com/pragdave/earmark/"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]

	code = "https://github.com/~foo/bar"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]
	end

	test "link with local mention" do
	insert(:user, %{nickname: "lain"})

	code = "https://example.com/@lain"
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><a href="#{code}">#{code}</a></p>]
	end

	test "local mentions" do
	mario = insert(:user, %{nickname: "mario"})
	luigi = insert(:user, %{nickname: "luigi"})

	code = "@mario @luigi yo what's up?"
	{result, _, []} = Utils.format_input(code, "text/markdown")

	assert result ==
	~s[<p><span class="h-card"><a class="u-url mention" data-user="#{mario.id}" href="#{mario.ap_id}" rel="ugc">@<span>mario</span></a></span> <span class="h-card"><a class="u-url mention" data-user="#{luigi.id}" href="#{luigi.ap_id}" rel="ugc">@<span>luigi</span></a></span> yo what's up?</p>]
	end

	test "remote mentions" do
	mario = insert(:user, %{nickname: "mario@mushroom.world", local: false})
	luigi = insert(:user, %{nickname: "luigi@mushroom.world", local: false})

	code = "@mario@mushroom.world @luigi@mushroom.world yo what's up?"
	{result, _, []} = Utils.format_input(code, "text/markdown")

	assert result ==
	~s[<p><span class="h-card"><a class="u-url mention" data-user="#{mario.id}" href="#{mario.ap_id}" rel="ugc">@<span>mario</span></a></span> <span class="h-card"><a class="u-url mention" data-user="#{luigi.id}" href="#{luigi.ap_id}" rel="ugc">@<span>luigi</span></a></span> yo what's up?</p>]
	end

	test "raw HTML" do
	code = ~s[<a href="http://example.org/">OwO</a><!-- what's this?-->]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<a href="http://example.org/">OwO</a>]
	end

	test "markdown links do not allow injected attributes" do
	code = ~s\|[click](http://example.com/?a=x" onerror="alert(1))\|
	{result, [], []} = Utils.format_input(code, "text/markdown")

	- assert result =~ ~s(<a href="http://example.com/?a=x">)
	+ assert result =~ ~s\|<a href="http://example.com/?a=x%22 onerror=%22alert(1)">\|
	refute result =~ ~s\|onerror="alert(1)\|
	refute result =~ ~s(<a href="http://example.com/?a=x" onerror=)
	end

	test "rulers" do
	code = ~s[before\n\n-----\n\nafter]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<p>before</p><hr/><p>after</p>"
	end

	test "blockquote" do
	code = ~s[> whoms't are you quoting?]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<blockquote><p>whoms't are you quoting?</p></blockquote>"
	end

	test "code" do
	code = ~s[`mix`]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><code class="inline">mix</code></p>]

	code = ~s[``mix``]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><code class="inline">mix</code></p>]

	code = ~s[```\nputs "Hello World"\n```]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<pre><code>puts "Hello World"</code></pre>]

	code = ~s[ <div>\n </div>]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<pre><code><div>\n</div></code></pre>]
	end

	test "lists" do
	code = ~s[- one\n- two\n- three\n- four]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<ul><li>one</li><li>two</li><li>three</li><li>four</li></ul>"

	code = ~s[1. one\n2. two\n3. three\n4. four\n]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == "<ol><li>one</li><li>two</li><li>three</li><li>four</li></ol>"
	end

	test "delegated renderers" do
	code = ~s[aaaa~]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><em>aaaa~</em></p>]

	code = ~s[aaaa~]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><strong>aaaa~</strong></p>]

	# strikethrough
	code = ~s[~~aaaa~~~]
	{result, [], []} = Utils.format_input(code, "text/markdown")
	assert result == ~s[<p><del>aaaa</del>~</p>]
	end
	end

	describe "formats date to asctime" do
	test "when date is in ISO 8601 format" do
	date = DateTime.utc_now() \|> DateTime.to_iso8601()

	expected =
	date
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> Calendar.Strftime.strftime!("%a %b %d %H:%M:%S %z %Y")

	assert Utils.date_to_asctime(date) == expected
	end

	test "when date is a binary in wrong format" do
	date = DateTime.utc_now()

	expected = ""

	assert capture_log(fn ->
	assert Utils.date_to_asctime(date) == expected
	end) =~ "Date #{date} in wrong format, must be ISO 8601"
	end

	test "when date is a Unix timestamp" do
	date = DateTime.utc_now() \|> DateTime.to_unix()

	expected = ""

	assert capture_log(fn ->
	assert Utils.date_to_asctime(date) == expected
	end) =~ "Date #{date} in wrong format, must be ISO 8601"
	end

	test "when date is nil" do
	expected = ""

	assert capture_log(fn ->
	assert Utils.date_to_asctime(nil) == expected
	end) =~ "Date in wrong format, must be ISO 8601"
	end

	test "when date is a random string" do
	assert capture_log(fn ->
	assert Utils.date_to_asctime("foo") == ""
	end) =~ "Date foo in wrong format, must be ISO 8601"
	end
	end

	describe "get_to_and_cc" do
	test "for public posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "public"}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert length(cc) == 1

	assert @public_address in to
	assert mentioned_user.ap_id in to
	assert user.follower_address in cc
	end

	test "for public posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "public",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 3
	assert length(cc) == 1

	assert @public_address in to
	assert mentioned_user.ap_id in to
	assert third_user.ap_id in to
	assert user.follower_address in cc
	end

	test "for unlisted posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "unlisted"}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert length(cc) == 1

	assert @public_address in cc
	assert mentioned_user.ap_id in to
	assert user.follower_address in to
	end

	test "for unlisted posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "unlisted",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 3
	assert length(cc) == 1

	assert @public_address in cc
	assert mentioned_user.ap_id in to
	assert third_user.ap_id in to
	assert user.follower_address in to
	end

	test "for private posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "private"}

	{to, cc} = Utils.get_to_and_cc(draft)
	assert length(to) == 2
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	assert user.follower_address in to
	end

	test "for private posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "private",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	assert user.follower_address in to
	end

	test "for direct posts, not a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "direct"}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 1
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	end

	test "for direct posts, a reply" do
	user = insert(:user)
	mentioned_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "direct",
	in_reply_to: activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 1
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to

	{:ok, direct_activity} = CommonAPI.post(third_user, %{status: "uguu", visibility: "direct"})

	draft = %ActivityDraft{
	user: user,
	mentions: [mentioned_user.ap_id],
	visibility: "direct",
	in_reply_to: direct_activity
	}

	{to, cc} = Utils.get_to_and_cc(draft)

	assert length(to) == 2
	assert Enum.empty?(cc)

	assert mentioned_user.ap_id in to
	assert third_user.ap_id in to
	end
	end

	describe "to_master_date/1" do
	test "removes microseconds from date (NaiveDateTime)" do
	assert Utils.to_masto_date(~N[2015-01-23 23:50:07.123]) == "2015-01-23T23:50:07.000Z"
	end

	test "removes microseconds from date (String)" do
	assert Utils.to_masto_date("2015-01-23T23:50:07.123Z") == "2015-01-23T23:50:07.000Z"
	end

	test "returns empty string when date invalid" do
	assert Utils.to_masto_date("2015-01?23T23:50:07.123Z") == ""
	end
	end

	describe "maybe_notify_mentioned_recipients/2" do
	test "returns recipients when activity is not `Create`" do
	activity = insert(:like_activity)
	assert Utils.maybe_notify_mentioned_recipients(["test"], activity) == ["test"]
	end

	test "returns recipients from tag" do
	user = insert(:user)

	object =
	insert(:note,
	user: user,
	data: %{
	"tag" => [
	%{"type" => "Hashtag"},
	"",
	%{"type" => "Mention", "href" => "https://testing.pleroma.lol/users/lain"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"}
	]
	}
	)

	activity = insert(:note_activity, user: user, note: object)

	assert Utils.maybe_notify_mentioned_recipients(["test"], activity) == [
	"test",
	"https://testing.pleroma.lol/users/lain",
	"https://shitposter.club/user/5381"
	]
	end

	test "returns recipients when object is map" do
	user = insert(:user)
	object = insert(:note, user: user)

	activity =
	insert(:note_activity,
	user: user,
	note: object,
	data_attrs: %{
	"object" => %{
	"tag" => [
	%{"type" => "Hashtag"},
	"",
	%{"type" => "Mention", "href" => "https://testing.pleroma.lol/users/lain"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"},
	%{"type" => "Mention", "href" => "https://shitposter.club/user/5381"}
	]
	}
	}
	)

	Pleroma.Repo.delete(object)

	assert Utils.maybe_notify_mentioned_recipients(["test"], activity) == [
	"test",
	"https://testing.pleroma.lol/users/lain",
	"https://shitposter.club/user/5381"
	]
	end

	test "returns recipients when object not found" do
	user = insert(:user)
	object = insert(:note, user: user)

	activity = insert(:note_activity, user: user, note: object)
	Pleroma.Repo.delete(object)

	obj_url = activity.data["object"]

	Tesla.Mock.mock(fn
	%{method: :get, url: ^obj_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	assert Utils.maybe_notify_mentioned_recipients(["test-test"], activity) == [
	"test-test"
	]
	end
	end

	describe "attachments_from_ids_descs/3" do
	test "returns [] when attachment ids is empty" do
	assert Utils.attachments_from_ids_descs([], "{}", nil) == []
	end

	test "returns list attachments with desc" do
	user = insert(:user)
	object = insert(:attachment, %{user: user})
	desc = Jason.encode!(%{object.id => "test-desc"})

	assert Utils.attachments_from_ids_descs(["#{object.id}", "34"], desc, user) == [
	Map.merge(object.data, %{"name" => "test-desc"})
	]
	end
	end

	describe "attachments_from_ids/2" do
	test "returns attachments with descs" do
	user = insert(:user)
	object = insert(:attachment, %{user: user})
	desc = Jason.encode!(%{object.id => "test-desc"})

	assert Utils.attachments_from_ids(
	%{
	media_ids: ["#{object.id}"],
	descriptions: desc
	},
	user
	) == [
	Map.merge(object.data, %{"name" => "test-desc"})
	]
	end

	test "returns attachments without descs" do
	user = insert(:user)
	object = insert(:attachment, %{user: user})
	assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}, user) == [object.data]
	end

	test "returns [] when not pass media_ids" do
	assert Utils.attachments_from_ids(%{}, nil) == []
	end

	test "returns [] when media_ids not belong to current user" do
	user = insert(:user)
	user2 = insert(:user)

	object = insert(:attachment, %{user: user})

	assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}, user2) == []
	end

	test "checks that the object is of upload type" do
	object = insert(:note)
	assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}, nil) == []
	end
	end

	describe "maybe_add_list_data/3" do
	test "adds list params when found user list" do
	user = insert(:user)
	{:ok, %Pleroma.List{} = list} = Pleroma.List.create(%{title: "title"}, user)

	assert Utils.maybe_add_list_data(%{additional: %{}, object: %{}}, user, {:list, list.id}) ==
	%{
	additional: %{"bcc" => [list.ap_id], "listMessage" => list.ap_id},
	object: %{"listMessage" => list.ap_id}
	}
	end

	test "returns original params when list not found" do
	user = insert(:user)
	{:ok, %Pleroma.List{} = list} = Pleroma.List.create(%{title: "title"}, insert(:user))

	assert Utils.maybe_add_list_data(%{additional: %{}, object: %{}}, user, {:list, list.id}) ==
	%{additional: %{}, object: %{}}
	end
	end

	describe "maybe_add_attachments/3" do
	test "returns parsed results when attachment_links is false" do
	assert Utils.maybe_add_attachments(
	{"test", [], ["tags"]},
	[],
	false
	) == {"test", [], ["tags"]}
	end

	test "adds attachments to parsed results" do
	attachment = %{"url" => [%{"href" => "SakuraPM.png"}]}

	assert Utils.maybe_add_attachments(
	{"test", [], ["tags"]},
	[attachment],
	true
	) == {
	"test<br><a href=\"SakuraPM.png\" class='attachment'>SakuraPM.png</a>",
	[],
	["tags"]
	}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 7:19 AM (8 h, 53 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802780
Default Alt Text: (51 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions