No OneTemporary
Actions

Size

14 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/test.exs b/config/test.exs
	index c2cc1085d..2234db9be 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,140 +1,142 @@
	import Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	url: [port: 4001],
	server: true

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, :console,
	level: :warn,
	format: "\n[$level] $message\n"

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload,
	filters: [],
	link_name: false,
	default_description: :filename

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false,
	static_dir: "test/instance_static/"

	config :pleroma, :activitypub, sign_object_fetches: false, follow_handshake_timeout: 0

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	port: System.get_env("DB_PORT") \|\| "5432",
	pool: Ecto.Adapters.SQL.Sandbox,
	pool_size: 50

	config :pleroma, :dangerzone, override_repo_pool_size: true

	# Reduce hash rounds for testing
	config :pleroma, :password, iterations: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"]

	config :pleroma, :instance,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	config :pleroma, Oban, testing: :manual

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit, %{}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	+config :pleroma, :http, send_user_agent: false
	+
	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	IO.puts("RUM enabled: #{rum_enabled}")

	config :joken, default_signer: "yU8uHKq+yyAkZ11Hx//jcdacWc8yQ1bxAAGrplzB0Zwwjkp35v0RK9SO8WTPr6QZ"

	config :pleroma, :modules, runtime_dir: "test/fixtures/modules"

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: true

	config :pleroma, Pleroma.Web.Plugs.RemoteIp, enabled: false

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: true

	config :tzdata, :autoupdate, :disabled

	config :pleroma, :mrf, policies: []

	config :pleroma, :pipeline,
	object_validator: Pleroma.Web.ActivityPub.ObjectValidatorMock,
	mrf: Pleroma.Web.ActivityPub.MRFMock,
	activity_pub: Pleroma.Web.ActivityPub.ActivityPubMock,
	side_effects: Pleroma.Web.ActivityPub.SideEffectsMock,
	federator: Pleroma.Web.FederatorMock,
	config: Pleroma.ConfigMock

	config :pleroma, :cachex, provider: Pleroma.CachexMock

	config :pleroma, Pleroma.Web.WebFinger, update_nickname_on_user_fetch: false

	config :pleroma, :side_effects,
	ap_streamer: Pleroma.Web.ActivityPub.ActivityPubMock,
	logger: Pleroma.LoggerMock

	# Reduce recompilation time
	# https://dashbit.co/blog/speeding-up-re-compilation-of-elixir-projects
	config :phoenix, :plug_init_mode, :runtime

	if File.exists?("./config/test.secret.exs") do
	import_config "test.secret.exs"
	else
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/lib/pleroma/http/request_builder.ex b/lib/pleroma/http/request_builder.ex
	index af679a00b..cebacd878 100644
	--- a/lib/pleroma/http/request_builder.ex
	+++ b/lib/pleroma/http/request_builder.ex
	@@ -1,94 +1,102 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.RequestBuilder do
	@moduledoc """
	Helper functions for building Tesla requests
	"""

	alias Pleroma.HTTP.Request
	alias Tesla.Multipart

	+ @mix_env Mix.env()
	+
	@doc """
	Creates new request
	"""
	@spec new(Request.t()) :: Request.t()
	def new(%Request{} = request \\ %Request{}), do: request

	@doc """
	Specify the request method when building a request
	"""
	@spec method(Request.t(), Request.method()) :: Request.t()
	def method(request, m), do: %{request \| method: m}

	@doc """
	Specify the request method when building a request
	"""
	@spec url(Request.t(), Request.url()) :: Request.t()
	def url(request, u), do: %{request \| url: u}

	@doc """
	Add headers to the request
	"""
	@spec headers(Request.t(), Request.headers()) :: Request.t()
	def headers(request, headers) do
	- headers_list =
	- with nil <- Enum.find(headers, fn {key, _val} -> String.downcase(key) == "user-agent" end) do
	- [{"user-agent", Pleroma.Application.user_agent()} \| headers]
	- else
	- _ ->
	- headers
	- end
	+ headers_list = maybe_add_user_agent(headers, @mix_env)

	%{request \| headers: headers_list}
	end

	@doc """
	Add custom, per-request middleware or adapter options to the request
	"""
	@spec opts(Request.t(), keyword()) :: Request.t()
	def opts(request, options), do: %{request \| opts: options}

	@doc """
	Add optional parameters to the request
	"""
	@spec add_param(Request.t(), atom(), atom(), any()) :: Request.t()
	def add_param(request, :query, :query, values), do: %{request \| query: values}

	def add_param(request, :body, :body, value), do: %{request \| body: value}

	def add_param(request, :body, key, value) do
	request
	\|> Map.put(:body, Multipart.new())
	\|> Map.update!(
	:body,
	&Multipart.add_field(
	&1,
	key,
	Jason.encode!(value),
	headers: [{"content-type", "application/json"}]
	)
	)
	end

	def add_param(request, :file, name, path) do
	request
	\|> Map.put(:body, Multipart.new())
	\|> Map.update!(:body, &Multipart.add_file(&1, path, name: name))
	end

	def add_param(request, :form, name, value) do
	Map.update(request, :body, %{name => value}, &Map.put(&1, name, value))
	end

	def add_param(request, location, key, value) do
	Map.update(request, location, [{key, value}], &(&1 ++ [{key, value}]))
	end

	def convert_to_keyword(request) do
	request
	\|> Map.from_struct()
	\|> Enum.into([])
	end
	+
	+ defp maybe_add_user_agent(headers, :test) do
	+ with true <- Pleroma.Config.get([:http, :send_user_agent]) do
	+ [{"user-agent", Pleroma.Application.user_agent()} \| headers]
	+ else
	+ _ ->
	+ headers
	+ end
	+ end
	+
	+ defp maybe_add_user_agent(headers, _),
	+ do: [{"user-agent", Pleroma.Application.user_agent()} \| headers]
	end
	diff --git a/test/pleroma/reverse_proxy_test.exs b/test/pleroma/reverse_proxy_test.exs
	index b90f67375..aa52ad561 100644
	--- a/test/pleroma/reverse_proxy_test.exs
	+++ b/test/pleroma/reverse_proxy_test.exs
	@@ -1,257 +1,255 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.ReverseProxy
	alias Plug.Conn

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

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

	conn = ReverseProxy.call(conn, url)

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

	test "use Pleroma's user agent in the request; don't pass the client's", %{conn: conn} do
	+ clear_config([:http, :send_user_agent], true)
	# Mock will fail if the client's user agent isn't filtered
	wanted_headers = [{"user-agent", Pleroma.Application.user_agent()}]

	Tesla.Mock.mock(fn %{url: "/user-agent", headers: ^wanted_headers} ->
	%Tesla.Env{
	status: 200,
	body: ""
	}
	end)

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

	assert response(conn, 200)
	end
	end

	describe "max_body" do
	test "length returns error if content-length more than option", %{conn: conn} do
	Tesla.Mock.mock(fn %{url: "/huge-file"} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-length", "100"}],
	body: "This body is too large."
	}
	end)

	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
	end

	describe "HEAD requests" do
	test "common", %{conn: conn} do
	Tesla.Mock.mock(fn %{method: :head, url: "/head"} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "text/html; charset=utf-8"}],
	body: ""
	}
	end)

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

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

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

	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
	url = "/status/400"

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

	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
	url = "/status/403"

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

	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
	end

	describe "keep request headers" do
	test "header passes", %{conn: conn} do
	Tesla.Mock.mock(fn %{url: "/headers"} ->
	%Tesla.Env{
	status: 200,
	body: ""
	}
	end)

	conn =
	Conn.put_req_header(
	conn,
	"accept",
	"text/html"
	)
	\|> ReverseProxy.call("/headers")

	assert response(conn, 200)
	assert {"accept", "text/html"} in conn.req_headers
	end

	test "header is filtered", %{conn: conn} do
	# Mock will fail if the accept-language header isn't filtered
	- wanted_headers = [
	- {"user-agent", Pleroma.Application.user_agent()},
	- {"accept-encoding", "*"}
	- ]
	+ wanted_headers = [{"accept-encoding", "*"}]

	Tesla.Mock.mock(fn %{url: "/headers", headers: ^wanted_headers} ->
	%Tesla.Env{
	status: 200,
	body: ""
	}
	end)

	conn =
	conn
	\|> Conn.put_req_header("accept-language", "en-US")
	\|> Conn.put_req_header("accept-encoding", "*")
	\|> ReverseProxy.call("/headers")

	assert response(conn, 200)
	end
	end

	test "returns 400 on non GET, HEAD requests", %{conn: conn} do
	Tesla.Mock.mock(fn %{url: "/ip"} ->
	%Tesla.Env{
	status: 200,
	body: ""
	}
	end)

	conn = ReverseProxy.call(Map.put(conn, :method, "POST"), "/ip")
	assert response(conn, 400)
	end

	describe "cache resp headers not filtered" do
	test "add cache-control", %{conn: conn} do
	Tesla.Mock.mock(fn %{url: "/cache"} ->
	%Tesla.Env{
	status: 200,
	headers: [
	{"cache-control", "public, max-age=1209600"},
	{"etag", "some ETag"},
	{"expires", "Wed, 21 Oct 2015 07:28:00 GMT"}
	],
	body: ""
	}
	end)

	conn = ReverseProxy.call(conn, "/cache")
	assert {"cache-control", "public, max-age=1209600"} in conn.resp_headers
	assert {"etag", "some ETag"} in conn.resp_headers
	assert {"expires", "Wed, 21 Oct 2015 07:28:00 GMT"} in conn.resp_headers
	end
	end

	describe "response content disposition header" do
	test "not attachment", %{conn: conn} do
	Tesla.Mock.mock(fn %{url: "/disposition"} ->
	%Tesla.Env{
	status: 200,
	headers: [
	{"content-type", "image/gif"},
	{"content-length", "0"}
	],
	body: ""
	}
	end)

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

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

	test "with content-disposition header", %{conn: conn} do
	Tesla.Mock.mock(fn %{url: "/disposition"} ->
	%Tesla.Env{
	status: 200,
	headers: [
	{"content-disposition", "attachment; filename=\"filename.jpg\""},
	{"content-length", "0"}
	],
	body: ""
	}
	end)

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

	assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Sep 18, 10:30 PM (4 h, 18 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768352
Default Alt Text: (14 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions