No OneTemporary
Actions

Authored By

Unknown

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/pleroma/reverse_proxy_test.exs b/test/pleroma/reverse_proxy_test.exs
	index a4dd8e99a..49ddf251d 100644
	--- a/test/pleroma/reverse_proxy_test.exs
	+++ b/test/pleroma/reverse_proxy_test.exs
	@@ -1,331 +1,331 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReverseProxyTest do
	use Pleroma.Web.ConnCase
	import ExUnit.CaptureLog
	import Mox

	alias Pleroma.ReverseProxy
	alias Pleroma.ReverseProxy.ClientMock
	alias Plug.Conn

	setup_all do
	{:ok, _} = Registry.start_link(keys: :unique, name: ClientMock)
	:ok
	end

	setup :verify_on_exit!

	defp request_mock(invokes) do
	ClientMock
	\|> expect(:request, fn :get, url, headers, _body, _opts ->
	Registry.register(ClientMock, url, 0)
	body = headers \|> Enum.into(%{}) \|> Jason.encode!()

	{:ok, 200,
	[
	{"content-type", "application/json"},
	{"content-length", byte_size(body) \|> to_string()}
	], %{url: url, body: body}}
	end)
	\|> expect(:stream_body, invokes, fn %{url: url, body: body} = client ->
	case Registry.lookup(ClientMock, url) do
	[{_, 0}] ->
	Registry.update_value(ClientMock, url, &(&1 + 1))
	{:ok, body, client}

	[{_, 1}] ->
	Registry.unregister(ClientMock, url)
	:done
	end
	end)
	end

	describe "reverse proxy" do
	test "do not track successful request", %{conn: conn} do
	request_mock(2)
	url = "/success"

	conn = ReverseProxy.call(conn, url)

	assert conn.status == 200
	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, nil}
	end
	end

	test "use Pleroma's user agent in the request; don't pass the client's", %{conn: conn} do
	request_mock(2)

	conn =
	conn
	\|> Plug.Conn.put_req_header("user-agent", "fake/1.0")
	\|> ReverseProxy.call("/user-agent")

	assert json_response(conn, 200) == %{"user-agent" => Pleroma.Application.user_agent()}
	end

	test "closed connection", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/closed", _, _, _ -> {:ok, 200, [], %{}} end)
	\|> expect(:stream_body, fn _ -> {:error, :closed} end)
	\|> expect(:close, fn _ -> :ok end)

	conn = ReverseProxy.call(conn, "/closed")
	assert conn.halted
	end

	defp stream_mock(invokes, with_close? \\ false) do
	ClientMock
	\|> expect(:request, fn :get, "/stream-bytes/" <> length, _, _, _ ->
	Registry.register(ClientMock, "/stream-bytes/" <> length, 0)

	{:ok, 200, [{"content-type", "application/octet-stream"}],
	%{url: "/stream-bytes/" <> length}}
	end)
	\|> expect(:stream_body, invokes, fn %{url: "/stream-bytes/" <> length} = client ->
	max = String.to_integer(length)

	case Registry.lookup(ClientMock, "/stream-bytes/" <> length) do
	[{_, current}] when current < max ->
	Registry.update_value(
	ClientMock,
	"/stream-bytes/" <> length,
	&(&1 + 10)
	)

	{:ok, "0123456789", client}

	[{_, ^max}] ->
	Registry.unregister(ClientMock, "/stream-bytes/" <> length)
	:done
	end
	end)

	if with_close? do
	expect(ClientMock, :close, fn _ -> :ok end)
	end
	end

	describe "max_body" do
	test "length returns error if content-length more than option", %{conn: conn} do
	request_mock(0)

	assert capture_log(fn ->
	ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
	end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to \"/huge-file\" failed: :body_too_large"

	assert {:ok, true} == Cachex.get(:failed_proxy_url_cache, "/huge-file")

	assert capture_log(fn ->
	ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
	end) == ""
	end

	test "max_body_length returns error if streaming body more than that option", %{conn: conn} do
	stream_mock(3, true)

	assert capture_log(fn ->
	ReverseProxy.call(conn, "/stream-bytes/50", max_body_length: 30)
	end) =~
	- "[warn] Elixir.Pleroma.ReverseProxy request to /stream-bytes/50 failed while reading/chunking: :body_too_large"
	+ "Elixir.Pleroma.ReverseProxy request to /stream-bytes/50 failed while reading/chunking: :body_too_large"
	end
	end

	describe "HEAD requests" do
	test "common", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :head, "/head", _, _, _ ->
	{:ok, 200, [{"content-type", "text/html; charset=utf-8"}]}
	end)

	conn = ReverseProxy.call(Map.put(conn, :method, "HEAD"), "/head")
	assert html_response(conn, 200) == ""
	end
	end

	defp error_mock(status) when is_integer(status) do
	ClientMock
	\|> expect(:request, fn :get, "/status/" <> _, _, _, _ ->
	{:error, status}
	end)
	end

	describe "returns error on" do
	test "500", %{conn: conn} do
	error_mock(500)
	url = "/status/500"

	capture_log(fn -> ReverseProxy.call(conn, url) end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to /status/500 failed with HTTP status 500"

	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}

	{:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
	assert ttl <= 60_000
	end

	test "400", %{conn: conn} do
	error_mock(400)
	url = "/status/400"

	capture_log(fn -> ReverseProxy.call(conn, url) end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to /status/400 failed with HTTP status 400"

	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
	assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
	end

	test "403", %{conn: conn} do
	error_mock(403)
	url = "/status/403"

	capture_log(fn ->
	ReverseProxy.call(conn, url, failed_request_ttl: :timer.seconds(120))
	end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to /status/403 failed with HTTP status 403"

	{:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
	assert ttl > 100_000
	end

	test "204", %{conn: conn} do
	url = "/status/204"
	expect(ClientMock, :request, fn :get, _url, _, _, _ -> {:ok, 204, [], %{}} end)

	capture_log(fn ->
	conn = ReverseProxy.call(conn, url)
	assert conn.resp_body == "Request failed: No Content"
	assert conn.halted
	end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to \"/status/204\" failed with HTTP status 204"

	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
	assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
	end
	end

	test "streaming", %{conn: conn} do
	stream_mock(21)
	conn = ReverseProxy.call(conn, "/stream-bytes/200")
	assert conn.state == :chunked
	assert byte_size(conn.resp_body) == 200
	assert Conn.get_resp_header(conn, "content-type") == ["application/octet-stream"]
	end

	defp headers_mock(_) do
	ClientMock
	\|> expect(:request, fn :get, "/headers", headers, _, _ ->
	Registry.register(ClientMock, "/headers", 0)
	{:ok, 200, [{"content-type", "application/json"}], %{url: "/headers", headers: headers}}
	end)
	\|> expect(:stream_body, 2, fn %{url: url, headers: headers} = client ->
	case Registry.lookup(ClientMock, url) do
	[{_, 0}] ->
	Registry.update_value(ClientMock, url, &(&1 + 1))
	headers = for {k, v} <- headers, into: %{}, do: {String.capitalize(k), v}
	{:ok, Jason.encode!(%{headers: headers}), client}

	[{_, 1}] ->
	Registry.unregister(ClientMock, url)
	:done
	end
	end)

	:ok
	end

	describe "keep request headers" do
	setup [:headers_mock]

	test "header passes", %{conn: conn} do
	conn =
	Conn.put_req_header(
	conn,
	"accept",
	"text/html"
	)
	\|> ReverseProxy.call("/headers")

	%{"headers" => headers} = json_response(conn, 200)
	assert headers["Accept"] == "text/html"
	end

	test "header is filtered", %{conn: conn} do
	conn =
	Conn.put_req_header(
	conn,
	"accept-language",
	"en-US"
	)
	\|> ReverseProxy.call("/headers")

	%{"headers" => headers} = json_response(conn, 200)
	refute headers["Accept-Language"]
	end
	end

	test "returns 400 on non GET, HEAD requests", %{conn: conn} do
	conn = ReverseProxy.call(Map.put(conn, :method, "POST"), "/ip")
	assert conn.status == 400
	end

	describe "cache resp headers" do
	test "add cache-control", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/cache", _, _, _ ->
	{:ok, 200, [{"ETag", "some ETag"}], %{}}
	end)
	\|> expect(:stream_body, fn _ -> :done end)

	conn = ReverseProxy.call(conn, "/cache")
	assert {"cache-control", "public, max-age=1209600"} in conn.resp_headers
	end
	end

	defp disposition_headers_mock(headers) do
	ClientMock
	\|> expect(:request, fn :get, "/disposition", _, _, _ ->
	Registry.register(ClientMock, "/disposition", 0)

	{:ok, 200, headers, %{url: "/disposition"}}
	end)
	\|> expect(:stream_body, 2, fn %{url: "/disposition"} = client ->
	case Registry.lookup(ClientMock, "/disposition") do
	[{_, 0}] ->
	Registry.update_value(ClientMock, "/disposition", &(&1 + 1))
	{:ok, "", client}

	[{_, 1}] ->
	Registry.unregister(ClientMock, "/disposition")
	:done
	end
	end)
	end

	describe "response content disposition header" do
	test "not atachment", %{conn: conn} do
	disposition_headers_mock([
	{"content-type", "image/gif"},
	{"content-length", "0"}
	])

	conn = ReverseProxy.call(conn, "/disposition")

	assert {"content-type", "image/gif"} in conn.resp_headers
	end

	test "with content-disposition header", %{conn: conn} do
	disposition_headers_mock([
	{"content-disposition", "attachment; filename=\"filename.jpg\""},
	{"content-length", "0"}
	])

	conn = ReverseProxy.call(conn, "/disposition")

	assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
	end
	end
	end
	diff --git a/test/pleroma/web/common_api/utils_test.exs b/test/pleroma/web/common_api/utils_test.exs
	index fc01f820a..7063b2503 100644
	--- a/test/pleroma/web/common_api/utils_test.exs
	+++ b/test/pleroma/web/common_api/utils_test.exs
	@@ -1,695 +1,695 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.UtilsTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	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 "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>]
	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 "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 "context_to_conversation_id" do
	test "creates a mapping object" do
	conversation_id = Utils.context_to_conversation_id("random context")
	object = Object.get_by_ap_id("random context")

	assert conversation_id == object.id
	end

	test "returns an existing mapping for an existing object" do
	{:ok, object} = Object.context_mapping("random context") \|> Repo.insert()
	conversation_id = Utils.context_to_conversation_id("random context")

	assert conversation_id == object.id
	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) =~ "[warn] Date #{date} in wrong format, must be ISO 8601"
	+ 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) =~ "[warn] Date #{date} in wrong format, must be ISO 8601"
	+ 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) =~ "[warn] Date in wrong format, must be ISO 8601"
	+ 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) =~ "[warn] Date foo in wrong format, must be ISO 8601"
	+ 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 "conversation_id_to_context/1" do
	test "returns id" do
	object = insert(:note)
	assert Utils.conversation_id_to_context(object.id) == object.data["id"]
	end

	test "returns error if object not found" do
	assert Utils.conversation_id_to_context("123") == {:error, "No such conversation"}
	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/2" do
	test "returns [] when attachment ids is empty" do
	assert Utils.attachments_from_ids_descs([], "{}") == []
	end

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

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

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

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

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

	test "returns [] when not pass media_ids" do
	assert Utils.attachments_from_ids(%{}) == []
	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", 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", 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
	diff --git a/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	index 5ed1f34b7..d8fc2400b 100644
	--- a/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	@@ -1,416 +1,417 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
	use Pleroma.Web.ConnCase, async: true
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory

	alias Pleroma.Filter
	alias Pleroma.Repo
	alias Pleroma.Workers.PurgeExpiredFilter

	test "non authenticated creation request", %{conn: conn} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{"phrase" => "knights", context: ["home"]})
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end

	describe "creating" do
	setup do: oauth_access(["write:filters"])

	test "a common filter", %{conn: conn, user: user} do
	params = %{
	phrase: "knights",
	context: ["home"],
	irreversible: true
	}

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", params)
	\|> json_response_and_validate_schema(200)

	assert response["phrase"] == params.phrase
	assert response["context"] == params.context
	assert response["irreversible"] == true
	assert response["id"] != nil
	assert response["id"] != ""
	assert response["expires_at"] == nil

	filter = Filter.get(response["id"], user)
	assert filter.hide == true
	end

	test "a filter with expires_in", %{conn: conn, user: user} do
	in_seconds = 600

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	"phrase" => "knights",
	context: ["home"],
	expires_in: in_seconds
	})
	\|> json_response_and_validate_schema(200)

	assert response["irreversible"] == false

	expected_expiration =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(in_seconds)

	{:ok, actual_expiration} = NaiveDateTime.from_iso8601(response["expires_at"])

	assert abs(NaiveDateTime.diff(expected_expiration, actual_expiration)) <= 5

	filter = Filter.get(response["id"], user)

	id = filter.id

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert {:ok, %{id: ^id}} =
	perform_job(PurgeExpiredFilter, %{
	filter_id: filter.id
	})

	assert Repo.aggregate(Filter, :count, :id) == 0
	end
	end

	test "fetching a list of filters" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

	%{filter_id: id1} = insert(:filter, user: user)
	%{filter_id: id2} = insert(:filter, user: user)

	id1 = to_string(id1)
	id2 = to_string(id2)

	assert [%{"id" => ^id2}, %{"id" => ^id1}] =
	conn
	\|> get("/api/v1/filters")
	\|> json_response_and_validate_schema(200)
	end

	test "fetching a list of filters without token", %{conn: conn} do
	insert(:filter)

	response =
	conn
	\|> get("/api/v1/filters")
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end

	test "get a filter" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

	# check whole_word false
	filter = insert(:filter, user: user, whole_word: false)

	resp1 =
	conn \|> get("/api/v1/filters/#{filter.filter_id}") \|> json_response_and_validate_schema(200)

	assert resp1["whole_word"] == false

	# check whole_word true
	filter = insert(:filter, user: user, whole_word: true)

	resp2 =
	conn \|> get("/api/v1/filters/#{filter.filter_id}") \|> json_response_and_validate_schema(200)

	assert resp2["whole_word"] == true
	end

	test "get a filter not_found error" do
	filter = insert(:filter)
	%{conn: conn} = oauth_access(["read:filters"])

	response =
	conn \|> get("/api/v1/filters/#{filter.filter_id}") \|> json_response_and_validate_schema(404)

	assert response["error"] == "Record not found"
	end

	describe "updating a filter" do
	setup do: oauth_access(["write:filters"])

	test "common" do
	%{conn: conn, user: user} = oauth_access(["write:filters"])

	filter =
	insert(:filter,
	user: user,
	hide: true,
	whole_word: true
	)

	params = %{
	phrase: "nii",
	context: ["public"],
	irreversible: false
	}

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", params)
	\|> json_response_and_validate_schema(200)

	assert response["phrase"] == params.phrase
	assert response["context"] == params.context
	assert response["irreversible"] == false
	assert response["whole_word"] == true
	end

	+ @tag :erratic
	test "with adding expires_at", %{conn: conn, user: user} do
	filter = insert(:filter, user: user)
	in_seconds = 600

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"],
	expires_in: in_seconds,
	irreversible: true
	})
	\|> json_response_and_validate_schema(200)

	assert response["irreversible"] == true

	assert response["expires_at"] ==
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(in_seconds)
	\|> Pleroma.Web.CommonAPI.Utils.to_masto_date()

	filter = Filter.get(response["id"], user)

	id = filter.id

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: id}
	)

	assert {:ok, %{id: ^id}} =
	perform_job(PurgeExpiredFilter, %{
	filter_id: id
	})

	assert Repo.aggregate(Filter, :count, :id) == 0
	end

	test "with removing expires_at", %{conn: conn, user: user} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(response["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"],
	expires_in: nil,
	whole_word: true
	})
	\|> json_response_and_validate_schema(200)

	refute_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert response["irreversible"] == false
	assert response["whole_word"] == true
	assert response["expires_at"] == nil
	end

	test "expires_at is the same in create and update so job is in db", %{conn: conn, user: user} do
	resp1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(resp1["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	job = PurgeExpiredFilter.get_expiration(filter.id)

	resp2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"]
	})
	\|> json_response_and_validate_schema(200)

	updated_filter = Filter.get(resp2["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: updated_filter.id}
	)

	after_update = PurgeExpiredFilter.get_expiration(updated_filter.id)

	assert resp1["expires_at"] == resp2["expires_at"]

	assert job.scheduled_at == after_update.scheduled_at
	end

	test "updating expires_at updates oban job too", %{conn: conn, user: user} do
	resp1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(resp1["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	job = PurgeExpiredFilter.get_expiration(filter.id)

	resp2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"],
	expires_in: 300
	})
	\|> json_response_and_validate_schema(200)

	updated_filter = Filter.get(resp2["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: updated_filter.id}
	)

	after_update = PurgeExpiredFilter.get_expiration(updated_filter.id)

	refute resp1["expires_at"] == resp2["expires_at"]

	refute job.scheduled_at == after_update.scheduled_at
	end
	end

	test "update filter without token", %{conn: conn} do
	filter = insert(:filter)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{filter.filter_id}", %{
	phrase: "nii",
	context: ["public"]
	})
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end

	describe "delete a filter" do
	setup do: oauth_access(["write:filters"])

	test "common", %{conn: conn, user: user} do
	filter = insert(:filter, user: user)

	assert conn
	\|> delete("/api/v1/filters/#{filter.filter_id}")
	\|> json_response_and_validate_schema(200) == %{}

	assert Repo.all(Filter) == []
	end

	test "with expires_at", %{conn: conn, user: user} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{
	phrase: "cofe",
	context: ["home"],
	expires_in: 600
	})
	\|> json_response_and_validate_schema(200)

	filter = Filter.get(response["id"], user)

	assert_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert conn
	\|> delete("/api/v1/filters/#{filter.filter_id}")
	\|> json_response_and_validate_schema(200) == %{}

	refute_enqueued(
	worker: PurgeExpiredFilter,
	args: %{filter_id: filter.id}
	)

	assert Repo.all(Filter) == []
	assert Repo.all(Oban.Job) == []
	end
	end

	test "delete a filter without token", %{conn: conn} do
	filter = insert(:filter)

	response =
	conn
	\|> delete("/api/v1/filters/#{filter.filter_id}")
	\|> json_response(403)

	assert response["error"] == "Invalid credentials."
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 3:37 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799350
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions