No OneTemporary
Actions

Size

51 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/http/request_builder.ex b/lib/pleroma/http/request_builder.ex
	index 6edf15bbe..4e77870bd 100644
	--- a/lib/pleroma/http/request_builder.ex
	+++ b/lib/pleroma/http/request_builder.ex
	@@ -1,151 +1,142 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	@doc """
	Specify the request method when building a request

	## Parameters

	- request (Map) - Collected request options
	- m (atom) - Request method

	## Returns

	Map
	"""
	@spec method(map(), atom) :: map()
	def method(request, m) do
	Map.put_new(request, :method, m)
	end

	@doc """
	Specify the request method when building a request

	## Parameters

	- request (Map) - Collected request options
	- u (String) - Request URL

	## Returns

	Map
	"""
	@spec url(map(), String.t()) :: map()
	def url(request, u) do
	Map.put_new(request, :url, u)
	end

	@doc """
	Add headers to the request
	"""
	@spec headers(map(), list(tuple)) :: map()
	def headers(request, header_list) do
	header_list =
	if Pleroma.Config.get([:http, :send_user_agent]) do
	header_list ++ [{"user-agent", Pleroma.Application.user_agent()}]
	else
	header_list
	end

	- # TODO: maybe we need this header for all adapters, so we won't fail on adapter change
	- header_list =
	- if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Gun do
	- %{host: host} = URI.parse(request.url)
	- header_list ++ [{"host", host}]
	- else
	- header_list
	- end
	-
	Map.put_new(request, :headers, header_list)
	end

	@doc """
	Add custom, per-request middleware or adapter options to the request
	"""
	@spec opts(map(), Keyword.t()) :: map()
	def opts(request, options) do
	Map.put_new(request, :opts, options)
	end

	@doc """
	Add optional parameters to the request

	## Parameters

	- request (Map) - Collected request options
	- definitions (Map) - Map of parameter name to parameter location.
	- options (KeywordList) - The provided optional parameters

	## Returns

	Map
	"""
	@spec add_optional_params(map(), %{optional(atom) => atom}, keyword()) :: map()
	def add_optional_params(request, _, []), do: request

	def add_optional_params(request, definitions, [{key, value} \| tail]) do
	case definitions do
	%{^key => location} ->
	request
	\|> add_param(location, key, value)
	\|> add_optional_params(definitions, tail)

	_ ->
	add_optional_params(request, definitions, tail)
	end
	end

	@doc """
	Add optional parameters to the request

	## Parameters

	- request (Map) - Collected request options
	- location (atom) - Where to put the parameter
	- key (atom) - The name of the parameter
	- value (any) - The value of the parameter

	## Returns

	Map
	"""
	@spec add_param(map(), atom, atom, any()) :: map()
	def add_param(request, :query, :query, values), do: Map.put(request, :query, values)

	def add_param(request, :body, :body, value), do: Map.put(request, :body, value)

	def add_param(request, :body, key, value) do
	request
	\|> Map.put_new_lazy(:body, &Tesla.Multipart.new/0)
	\|> Map.update!(
	:body,
	&Tesla.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_new_lazy(:body, &Tesla.Multipart.new/0)
	\|> Map.update!(:body, &Tesla.Multipart.add_file(&1, path, name: name))
	end

	def add_param(request, :form, name, value) do
	request
	\|> Map.update(: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
	end
	diff --git a/mix.exs b/mix.exs
	index d156b9e36..29f1c90c5 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,274 +1,275 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("1.0.0"),
	elixir: "~> 1.7",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: [:phoenix, :gettext] ++ Mix.compilers(),
	elixirc_options: [warnings_as_errors: true],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: ExCoveralls],
	preferred_cli_env: ["coveralls.html": :test],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/static/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load],
	steps: [:assemble, &copy_files/1, &copy_nginx_config/1]
	]
	]
	]
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications: [:logger, :runtime_tools, :comeonin, :quack],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.4.8"},
	{:tzdata, "~> 0.5.21"},
	{:plug_cowboy, "~> 2.0"},
	{:phoenix_pubsub, "~> 1.1"},
	{:phoenix_ecto, "~> 4.0"},
	{:ecto_sql, "~> 3.1"},
	{:postgrex, ">= 0.13.5"},
	{:gettext, "~> 0.15"},
	{:comeonin, "~> 4.1.1"},
	{:pbkdf2_elixir, "~> 0.12.3"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:html_sanitize_ex, "~> 1.3.0"},
	{:html_entities, "~> 0.4"},
	{:phoenix_html, "~> 2.10"},
	{:calendar, "~> 0.17.4"},
	{:cachex, "~> 3.0.2"},
	{:poison, "~> 3.0", override: true},
	{
	:tesla,
	github: "alex-strizhakov/tesla",
	- ref: "33ba3bbd44d6fddd6558aaf4d9768c8de5f279b8",
	+ ref: "929d68446a9b9d08149bd92d5b51c7ae9f87cfee",
	override: true
	},
	- {:cowlib, "~> 2.6.0", override: true},
	- {:gun, "~> 1.3"},
	+ {:cowlib, "~> 2.7.3", override: true},
	+ {:gun,
	+ github: "ninenines/gun", ref: "491ddf58c0e14824a741852fdc522b390b306ae2", override: true},
	{:jason, "~> 1.0"},
	{:mogrify, "~> 0.6.1"},
	{:ex_aws, "~> 2.1"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.6.6"},
	{:earmark, "~> 1.3"},
	{:bbcode, "~> 0.1.1"},
	{:ex_machina, "~> 2.3", only: :test},
	{:credo, "~> 0.9.3", only: [:dev, :test]},
	{:mock, "~> 0.3.3", only: :test},
	{:crypt,
	git: "https://github.com/msantos/crypt", ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"},
	{:cors_plug, "~> 1.5"},
	{:ex_doc, "~> 0.20.2", only: :dev, runtime: false},
	{:web_push_encryption, "~> 0.2.1"},
	{:swoosh, "~> 0.23.2"},
	{:phoenix_swoosh, "~> 0.2"},
	{:gen_smtp, "~> 0.13"},
	{:websocket_client, git: "https://github.com/jeremyong/websocket_client.git", only: :test},
	{:floki, "~> 0.20.0"},
	{:ex_syslogger, github: "slashmili/ex_syslogger", tag: "1.4.0"},
	{:timex, "~> 3.5"},
	{:ueberauth, "~> 0.4"},
	{:auto_linker,
	git: "https://git.pleroma.social/pleroma/auto_linker.git",
	ref: "95e8188490e97505c56636c1379ffdf036c1fdde"},
	{:http_signatures,
	git: "https://git.pleroma.social/pleroma/http_signatures.git",
	ref: "293d77bb6f4a67ac8bde1428735c3b42f22cbb30"},
	{:pleroma_job_queue, "~> 0.3"},
	{:telemetry, "~> 0.3"},
	{:prometheus_ex, "~> 3.0"},
	{:prometheus_plugs, "~> 1.1"},
	{:prometheus_phoenix, "~> 1.3"},
	{:prometheus_ecto, "~> 1.4"},
	{:recon, github: "ferd/recon", tag: "2.4.0"},
	{:quack, "~> 0.1.1"},
	{:joken, "~> 2.0"},
	{:benchee, "~> 1.0"},
	{:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_rated, "~> 1.3"},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:excoveralls, "~> 0.11.1", only: :test},
	{:mox, "~> 0.5", only: :test}
	] ++ oauth_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"]
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	# Pre-release version, denoted from patch version with a hyphen
	{git_tag, git_pre_release} =
	with {tag, 0} <-
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true),
	tag = String.trim(tag),
	{describe, 0} <- System.cmd("git", ["describe", "--tags", "--abbrev=8"]),
	describe = String.trim(describe),
	ahead <- String.replace(describe, tag, ""),
	ahead <- String.trim_leading(ahead, "-") do
	{String.replace_prefix(tag, "v", ""), if(ahead != "", do: String.trim(ahead))}
	else
	_ ->
	{commit_hash, 0} = System.cmd("git", ["rev-parse", "--short", "HEAD"])
	{nil, "0-g" <> String.trim(commit_hash)}
	end

	if git_tag && version != git_tag do
	Mix.shell().error(
	"Application version #{inspect(version)} does not match git tag #{inspect(git_tag)}"
	)
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with {branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <- branch_name not in ["master", "HEAD"] do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 606dbfa61..1d4532fed 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,97 +1,97 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm"},
	"auto_linker": {:git, "https://git.pleroma.social/pleroma/auto_linker.git", "95e8188490e97505c56636c1379ffdf036c1fdde", [ref: "95e8188490e97505c56636c1379ffdf036c1fdde"]},
	"base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "hexpm"},
	"bbcode": {:hex, :bbcode, "0.1.1", "0023e2c7814119b2e620b7add67182e3f6019f92bfec9a22da7e99821aceba70", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
	"benchee": {:hex, :benchee, "1.0.1", "66b211f9bfd84bd97e6d1beaddf8fc2312aaabe192f776e8931cb0c16f53a521", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}], "hexpm"},
	"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"},
	"cachex": {:hex, :cachex, "3.0.3", "4e2d3e05814a5738f5ff3903151d5c25636d72a3527251b753f501ad9c657967", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm"},
	"calendar": {:hex, :calendar, "0.17.6", "ec291cb2e4ba499c2e8c0ef5f4ace974e2f9d02ae9e807e711a9b0c7850b9aee", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
	"certifi": {:hex, :certifi, "2.5.1", "867ce347f7c7d78563450a18a6a28a8090331e77fa02380b4a21962a65d36ee5", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm"},
	"comeonin": {:hex, :comeonin, "4.1.2", "3eb5620fd8e35508991664b4c2b04dd41e52f1620b36957be837c1d7784b7592", [:mix], [{:argon2_elixir, "~> 1.2", [hex: :argon2_elixir, repo: "hexpm", optional: true]}, {:bcrypt_elixir, "~> 0.12.1 or ~> 1.0", [hex: :bcrypt_elixir, repo: "hexpm", optional: true]}, {:pbkdf2_elixir, "~> 0.12", [hex: :pbkdf2_elixir, repo: "hexpm", optional: true]}], "hexpm"},
	"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
	"cors_plug": {:hex, :cors_plug, "1.5.2", "72df63c87e4f94112f458ce9d25800900cc88608c1078f0e4faddf20933eda6e", [:mix], [{:plug, "~> 1.3 or ~> 1.4 or ~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"cowboy": {:hex, :cowboy, "2.6.3", "99aa50e94e685557cad82e704457336a453d4abcb77839ad22dbe71f311fcc06", [:rebar3], [{:cowlib, "~> 2.7.3", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
	- "cowlib": {:hex, :cowlib, "2.6.0", "8aa629f81a0fc189f261dc98a42243fa842625feea3c7ec56c48f4ccdb55490f", [:rebar3], [], "hexpm"},
	+ "cowlib": {:hex, :cowlib, "2.7.3", "a7ffcd0917e6d50b4d5fb28e9e2085a0ceb3c97dea310505f7460ff5ed764ce9", [:rebar3], [], "hexpm"},
	"credo": {:hex, :credo, "0.9.3", "76fa3e9e497ab282e0cf64b98a624aa11da702854c52c82db1bf24e54ab7c97a", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:poison, ">= 0.0.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	"crontab": {:hex, :crontab, "1.1.7", "b9219f0bdc8678b94143655a8f229716c5810c0636a4489f98c0956137e53985", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"crypt": {:git, "https://github.com/msantos/crypt", "1f2b58927ab57e72910191a7ebaeff984382a1d3", [ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"]},
	"db_connection": {:hex, :db_connection, "2.0.6", "bde2f85d047969c5b5800cb8f4b3ed6316c8cb11487afedac4aa5f93fd39abfa", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
	"decimal": {:hex, :decimal, "1.8.0", "ca462e0d885f09a1c5a342dbd7c1dcf27ea63548c65a65e67334f4b61803822e", [:mix], [], "hexpm"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm"},
	"earmark": {:hex, :earmark, "1.3.2", "b840562ea3d67795ffbb5bd88940b1bed0ed9fa32834915125ea7d02e35888a5", [:mix], [], "hexpm"},
	"ecto": {:hex, :ecto, "3.1.4", "69d852da7a9f04ede725855a35ede48d158ca11a404fe94f8b2fb3b2162cd3c9", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
	"ecto_sql": {:hex, :ecto_sql, "3.1.3", "2c536139190492d9de33c5fefac7323c5eaaa82e1b9bf93482a14649042f7cd9", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.1.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:myxql, "~> 0.2.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
	"esshd": {:hex, :esshd, "0.1.0", "6f93a2062adb43637edad0ea7357db2702a4b80dd9683482fe00f5134e97f4c1", [:mix], [], "hexpm"},
	"eternal": {:hex, :eternal, "1.2.0", "e2a6b6ce3b8c248f7dc31451aefca57e3bdf0e48d73ae5043229380a67614c41", [:mix], [], "hexpm"},
	"ex2ms": {:hex, :ex2ms, "1.5.0", "19e27f9212be9a96093fed8cdfbef0a2b56c21237196d26760f11dfcfae58e97", [:mix], [], "hexpm"},
	"ex_aws": {:hex, :ex_aws, "2.1.0", "b92651527d6c09c479f9013caa9c7331f19cba38a650590d82ebf2c6c16a1d8a", [:mix], [{:configparser_ex, "~> 2.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "1.6.3 or 1.6.5 or 1.7.1 or 1.8.6 or ~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8", [hex: :jsx, repo: "hexpm", optional: true]}, {:poison, ">= 1.2.0", [hex: :poison, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}, {:xml_builder, "~> 0.1.0", [hex: :xml_builder, repo: "hexpm", optional: true]}], "hexpm"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.0.1", "9e09366e77f25d3d88c5393824e613344631be8db0d1839faca49686e99b6704", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm"},
	"ex_doc": {:hex, :ex_doc, "0.20.2", "1bd0dfb0304bade58beb77f20f21ee3558cc3c753743ae0ddbb0fd7ba2912331", [:mix], [{:earmark, "~> 1.3", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.10", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm"},
	"ex_machina": {:hex, :ex_machina, "2.3.0", "92a5ad0a8b10ea6314b876a99c8c9e3f25f4dde71a2a835845b136b9adaf199a", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm"},
	"ex_rated": {:hex, :ex_rated, "1.3.3", "30ecbdabe91f7eaa9d37fa4e81c85ba420f371babeb9d1910adbcd79ec798d27", [:mix], [{:ex2ms, "~> 1.5", [hex: :ex2ms, repo: "hexpm", optional: false]}], "hexpm"},
	"ex_syslogger": {:git, "https://github.com/slashmili/ex_syslogger.git", "f3963399047af17e038897c69e20d552e6899e1d", [tag: "1.4.0"]},
	"excoveralls": {:hex, :excoveralls, "0.11.1", "dd677fbdd49114fdbdbf445540ec735808250d56b011077798316505064edb2c", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"},
	"floki": {:hex, :floki, "0.20.4", "be42ac911fece24b4c72f3b5846774b6e61b83fe685c2fc9d62093277fb3bc86", [:mix], [{:html_entities, "~> 0.4.0", [hex: :html_entities, repo: "hexpm", optional: false]}, {:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	"gen_smtp": {:hex, :gen_smtp, "0.14.0", "39846a03522456077c6429b4badfd1d55e5e7d0fdfb65e935b7c5e38549d9202", [:rebar3], [], "hexpm"},
	"gettext": {:hex, :gettext, "0.17.0", "abe21542c831887a2b16f4c94556db9c421ab301aee417b7c4fbde7fbdbe01ec", [:mix], [], "hexpm"},
	- "gun": {:hex, :gun, "1.3.0", "18e5d269649c987af95aec309f68a27ffc3930531dd227a6eaa0884d6684286e", [:rebar3], [{:cowlib, "~> 2.6.0", [hex: :cowlib, repo: "hexpm", optional: false]}], "hexpm"},
	+ "gun": {:git, "https://github.com/ninenines/gun.git", "491ddf58c0e14824a741852fdc522b390b306ae2", [ref: "491ddf58c0e14824a741852fdc522b390b306ae2"]},
	"hackney": {:hex, :hackney, "1.15.1", "9f8f471c844b8ce395f7b6d8398139e26ddca9ebc171a8b91342ee15a19963f4", [:rebar3], [{:certifi, "2.5.1", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "6.0.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.4", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm"},
	"html_entities": {:hex, :html_entities, "0.4.0", "f2fee876858cf6aaa9db608820a3209e45a087c5177332799592142b50e89a6b", [:mix], [], "hexpm"},
	"html_sanitize_ex": {:hex, :html_sanitize_ex, "1.3.0", "f005ad692b717691203f940c686208aa3d8ffd9dd4bb3699240096a51fa9564e", [:mix], [{:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	"http_signatures": {:git, "https://git.pleroma.social/pleroma/http_signatures.git", "293d77bb6f4a67ac8bde1428735c3b42f22cbb30", [ref: "293d77bb6f4a67ac8bde1428735c3b42f22cbb30"]},
	"httpoison": {:hex, :httpoison, "1.2.0", "2702ed3da5fd7a8130fc34b11965c8cfa21ade2f232c00b42d96d4967c39a3a3", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	"idna": {:hex, :idna, "6.0.0", "689c46cbcdf3524c44d5f3dde8001f364cd7608a99556d8fbd8239a5798d4c10", [:rebar3], [{:unicode_util_compat, "0.4.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"},
	"jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
	"joken": {:hex, :joken, "2.0.1", "ec9ab31bf660f343380da033b3316855197c8d4c6ef597fa3fcb451b326beb14", [:mix], [{:jose, "~> 1.9", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm"},
	"jose": {:hex, :jose, "1.9.0", "4167c5f6d06ffaebffd15cdb8da61a108445ef5e85ab8f5a7ad926fdf3ada154", [:mix, :rebar3], [{:base64url, "~> 0.0.1", [hex: :base64url, repo: "hexpm", optional: false]}], "hexpm"},
	"makeup": {:hex, :makeup, "0.8.0", "9cf32aea71c7fe0a4b2e9246c2c4978f9070257e5c9ce6d4a28ec450a839b55f", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.13.0", "be7a477997dcac2e48a9d695ec730b2d22418292675c75aa2d34ba0909dcdeda", [:mix], [{:makeup, "~> 0.8", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"},
	"meck": {:hex, :meck, "0.8.13", "ffedb39f99b0b99703b8601c6f17c7f76313ee12de6b646e671e3188401f7866", [:rebar3], [], "hexpm"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm"},
	"mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm"},
	"mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.3", "42a433794b1291a9cf1525c6d26b38e039e0d3a360732b5e467bfc77ef26c914", [:mix], [{:meck, "~> 0.8.13", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm"},
	"mogrify": {:hex, :mogrify, "0.6.1", "de1b527514f2d95a7bbe9642eb556061afb337e220cf97adbf3a4e6438ed70af", [:mix], [], "hexpm"},
	"mox": {:hex, :mox, "0.5.1", "f86bb36026aac1e6f924a4b6d024b05e9adbed5c63e8daa069bd66fb3292165b", [:mix], [], "hexpm"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.5.0", "90e2eca3d0266e5c53f8fbe0079694740b9c91b6747f2b7e3c5d21966bba8300", [:mix], [], "hexpm"},
	"parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm"},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "0.12.3", "6706a148809a29c306062862c803406e88f048277f6e85b68faf73291e820b84", [:mix], [], "hexpm"},
	"phoenix": {:hex, :phoenix, "1.4.9", "746d098e10741c334d88143d3c94cab1756435f94387a63441792e66ec0ee974", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.0.0", "c43117a136e7399ea04ecaac73f8f23ee0ffe3e07acfcb8062fe5f4c9f0f6531", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_html": {:hex, :phoenix_html, "2.13.1", "fa8f034b5328e2dfa0e4131b5569379003f34bc1fafdaa84985b0b9d2f12e68b", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "1.1.2", "496c303bdf1b2e98a9d26e89af5bba3ab487ba3a3735f74bf1f4064d2a845a3e", [:mix], [], "hexpm"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "0.2.0", "a7e0b32077cd6d2323ae15198839b05d9caddfa20663fd85787479e81f89520e", [:mix], [{:phoenix, "~> 1.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.2", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:swoosh, "~> 0.1", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm"},
	"pleroma_job_queue": {:hex, :pleroma_job_queue, "0.3.0", "b84538d621f0c3d6fcc1cff9d5648d3faaf873b8b21b94e6503428a07a48ec47", [:mix], [{:crontab, "~> 1.1", [hex: :crontab, repo: "hexpm", optional: false]}], "hexpm"},
	"plug": {:hex, :plug, "1.8.2", "0bcce1daa420f189a6491f3940cc77ea7fb1919761175c9c3b59800d897440fc", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.1.0", "b75768153c3a8a9e8039d4b25bb9b14efbc58e9c4a6e6a270abff1cd30cbe320", [:mix], [{:cowboy, "~> 2.5", [hex: :cowboy, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"plug_crypto": {:hex, :plug_crypto, "1.0.0", "18e49317d3fa343f24620ed22795ec29d4a5e602d52d1513ccea0b07d8ea7d4d", [:mix], [], "hexpm"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"},
	"postgrex": {:hex, :postgrex, "0.14.3", "5754dee2fdf6e9e508cbf49ab138df964278700b764177e8f3871e658b345a1e", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
	"prometheus": {:hex, :prometheus, "4.4.1", "1e96073b3ed7788053768fea779cbc896ddc3bdd9ba60687f2ad50b252ac87d6", [:mix, :rebar3], [], "hexpm"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.1", "6c768ea9654de871e5b32fab2eac348467b3021604ebebbcbd8bcbe806a65ed5", [:mix], [{:ecto, "~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm"},
	"prometheus_ex": {:hex, :prometheus_ex, "3.0.5", "fa58cfd983487fc5ead331e9a3e0aa622c67232b3ec71710ced122c4c453a02f", [:mix], [{:prometheus, "~> 4.0", [hex: :prometheus, repo: "hexpm", optional: false]}], "hexpm"},
	"prometheus_phoenix": {:hex, :prometheus_phoenix, "1.3.0", "c4b527e0b3a9ef1af26bdcfbfad3998f37795b9185d475ca610fe4388fdd3bb5", [:mix], [{:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.3 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm"},
	"prometheus_plugs": {:hex, :prometheus_plugs, "1.1.5", "25933d48f8af3a5941dd7b621c889749894d8a1082a6ff7c67cc99dec26377c5", [:mix], [{:accept, "~> 0.1", [hex: :accept, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}, {:prometheus_process_collector, "~> 1.1", [hex: :prometheus_process_collector, repo: "hexpm", optional: true]}], "hexpm"},
	"quack": {:hex, :quack, "0.1.1", "cca7b4da1a233757fdb44b3334fce80c94785b3ad5a602053b7a002b5a8967bf", [:mix], [{:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: false]}, {:tesla, "~> 1.2.0", [hex: :tesla, repo: "hexpm", optional: false]}], "hexpm"},
	"ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm"},
	"recon": {:git, "https://github.com/ferd/recon.git", "75d70c7c08926d2f24f1ee6de14ee50fe8a52763", [tag: "2.4.0"]},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.4", "f0eafff810d2041e93f915ef59899c923f4568f4585904d010387ed74988e77b", [:make, :mix, :rebar3], [], "hexpm"},
	"sweet_xml": {:hex, :sweet_xml, "0.6.6", "fc3e91ec5dd7c787b6195757fbcf0abc670cee1e4172687b45183032221b66b8", [:mix], [], "hexpm"},
	"swoosh": {:hex, :swoosh, "0.23.2", "7dda95ff0bf54a2298328d6899c74dae1223777b43563ccebebb4b5d2b61df38", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm"},
	"syslog": {:git, "https://github.com/Vagabond/erlang-syslog.git", "4a6c6f2c996483e86c1320e9553f91d337bcb6aa", [tag: "1.0.5"]},
	"telemetry": {:hex, :telemetry, "0.4.0", "8339bee3fa8b91cb84d14c2935f8ecf399ccd87301ad6da6b71c09553834b2ab", [:rebar3], [], "hexpm"},
	- "tesla": {:git, "https://github.com/alex-strizhakov/tesla.git", "33ba3bbd44d6fddd6558aaf4d9768c8de5f279b8", [ref: "33ba3bbd44d6fddd6558aaf4d9768c8de5f279b8"]},
	+ "tesla": {:git, "https://github.com/alex-strizhakov/tesla.git", "929d68446a9b9d08149bd92d5b51c7ae9f87cfee", [ref: "929d68446a9b9d08149bd92d5b51c7ae9f87cfee"]},
	"timex": {:hex, :timex, "3.6.1", "efdf56d0e67a6b956cc57774353b0329c8ab7726766a11547e529357ffdc1d56", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 0.1.8 or ~> 0.5 or ~> 1.0.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"tzdata": {:hex, :tzdata, "0.5.21", "8cbf3607fcce69636c672d5be2bbb08687fe26639a62bdcc283d267277db7cf0", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	"ueberauth": {:hex, :ueberauth, "0.6.1", "9e90d3337dddf38b1ca2753aca9b1e53d8a52b890191cdc55240247c89230412", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.4.1", "d869e4c68901dd9531385bb0c8c40444ebf624e60b6962d95952775cac5e90cd", [:rebar3], [], "hexpm"},
	"unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.2.1", "d42cecf73420d9dc0053ba3299cc8c8d6ff2be2487d67ca2a57265868e4d9a98", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.8", [hex: :jose, repo: "hexpm", optional: false]}, {:poison, "~> 3.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	"websocket_client": {:git, "https://github.com/jeremyong/websocket_client.git", "9a6f65d05ebf2725d62fb19262b21f1805a59fbf", []},
	}
	diff --git a/test/http/request_builder_test.exs b/test/http/request_builder_test.exs
	index 73eaac273..331399bd2 100644
	--- a/test/http/request_builder_test.exs
	+++ b/test/http/request_builder_test.exs
	@@ -1,106 +1,95 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.RequestBuilderTest do
	use ExUnit.Case
	alias Pleroma.HTTP.RequestBuilder

	describe "headers/2" do
	test "don't send pleroma user agent" do
	assert RequestBuilder.headers(%{}, []) == %{headers: []}
	end

	test "send pleroma user agent" do
	send = Pleroma.Config.get([:http, :send_user_agent])
	Pleroma.Config.put([:http, :send_user_agent], true)

	on_exit(fn ->
	Pleroma.Config.put([:http, :send_user_agent], send)
	end)

	assert RequestBuilder.headers(%{}, []) == %{
	headers: [{"user-agent", Pleroma.Application.user_agent()}]
	}
	end
	-
	- test "it adds host header for gun adapter" do
	- adapter = Application.get_env(:tesla, :adapter)
	- Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)
	- on_exit(fn -> Application.put_env(:tesla, :adapter, adapter) end)
	-
	- assert RequestBuilder.headers(%{url: "https://example.com"}, []) == %{
	- headers: [{"host", "example.com"}],
	- url: "https://example.com"
	- }
	- end
	end

	describe "add_optional_params/3" do
	test "don't add if keyword is empty" do
	assert RequestBuilder.add_optional_params(%{}, %{}, []) == %{}
	end

	test "add query parameter" do
	assert RequestBuilder.add_optional_params(
	%{},
	%{query: :query, body: :body, another: :val},
	[
	{:query, "param1=val1&param2=val2"},
	{:body, "some body"}
	]
	) == %{query: "param1=val1&param2=val2", body: "some body"}
	end
	end

	describe "add_param/4" do
	test "add file parameter" do
	%{
	body: %Tesla.Multipart{
	boundary: _,
	content_type_params: [],
	parts: [
	%Tesla.Multipart.Part{
	body: %File.Stream{
	line_or_bytes: 2048,
	modes: [:raw, :read_ahead, :read, :binary],
	path: "some-path/filename.png",
	raw: true
	},
	dispositions: [name: "filename.png", filename: "filename.png"],
	headers: []
	}
	]
	}
	} = RequestBuilder.add_param(%{}, :file, "filename.png", "some-path/filename.png")
	end

	test "add key to body" do
	%{
	body: %Tesla.Multipart{
	boundary: _,
	content_type_params: [],
	parts: [
	%Tesla.Multipart.Part{
	body: "\"someval\"",
	dispositions: [name: "somekey"],
	headers: ["Content-Type": "application/json"]
	}
	]
	}
	} = RequestBuilder.add_param(%{}, :body, "somekey", "someval")
	end

	test "add form parameter" do
	assert RequestBuilder.add_param(%{}, :form, "somename", "someval") == %{
	body: %{"somename" => "someval"}
	}
	end

	test "add for location" do
	assert RequestBuilder.add_param(%{}, :some_location, "somekey", "someval") == %{
	some_location: [{"somekey", "someval"}]
	}
	end
	end
	end
	diff --git a/test/reverse_proxy/reverse_proxy_test.exs b/test/reverse_proxy/reverse_proxy_test.exs
	index e3c26c676..87ee639df 100644
	--- a/test/reverse_proxy/reverse_proxy_test.exs
	+++ b/test/reverse_proxy/reverse_proxy_test.exs
	@@ -1,388 +1,387 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 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

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

	setup :verify_on_exit!

	defp user_agent_mock(user_agent, invokes) do
	json = Jason.encode!(%{"user-agent": user_agent})

	ClientMock
	\|> expect(:request, fn :get, url, _, _, _ ->
	Registry.register(Pleroma.ReverseProxy.ClientMock, url, 0)

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

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

	describe "user-agent" do
	test "don't keep", %{conn: conn} do
	user_agent_mock("hackney/1.15.1", 2)
	conn = ReverseProxy.call(conn, "/user-agent")
	assert json_response(conn, 200) == %{"user-agent" => "hackney/1.15.1"}
	end

	test "keep", %{conn: conn} do
	user_agent_mock(Pleroma.Application.user_agent(), 2)
	conn = ReverseProxy.call(conn, "/user-agent-keep", keep_user_agent: true)
	assert json_response(conn, 200) == %{"user-agent" => Pleroma.Application.user_agent()}
	end
	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(Pleroma.ReverseProxy.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(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length) do
	[{_, current}] when current < max ->
	Registry.update_value(
	Pleroma.ReverseProxy.ClientMock,
	"/stream-bytes/" <> length,
	&(&1 + 10)
	)

	{:ok, "0123456789", client}

	[{_, ^max}] ->
	Registry.unregister(Pleroma.ReverseProxy.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
	user_agent_mock("hackney/1.15.1", 0)

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

	test "max_body_size 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_size: 30)
	end) =~
	"[warn] 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)

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

	test "400", %{conn: conn} do
	error_mock(400)

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

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

	capture_log(fn ->
	conn = ReverseProxy.call(conn, "/status/204")
	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"
	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 Plug.Conn.get_resp_header(conn, "content-type") == ["application/octet-stream"]
	end

	defp headers_mock(_) do
	ClientMock
	\|> expect(:request, fn :get, "/headers", headers, _, _ ->
	Registry.register(Pleroma.ReverseProxy.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(Pleroma.ReverseProxy.ClientMock, url) do
	[{_, 0}] ->
	Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
	headers = for {k, v} <- headers, into: %{}, do: {String.capitalize(k), v}
	{:ok, Jason.encode!(%{headers: headers}), client}

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

	:ok
	end

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

	test "header passes", %{conn: conn} do
	conn =
	Plug.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 =
	Plug.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 "returns headers", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/cache/" <> ttl, _, _, _ ->
	{:ok, 200, [{"cache-control", "public, max-age=" <> ttl}], %{}}
	end)
	\|> expect(:stream_body, fn _ -> :done end)

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

	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"} in conn.resp_headers
	end
	end

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

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

	[{_, 1}] ->
	Registry.unregister(Pleroma.ReverseProxy.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

	describe "integration tests" do
	@describetag :integration

	test "with hackney client", %{conn: conn} do
	client = Pleroma.Config.get([Pleroma.ReverseProxy.Client])
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], Pleroma.ReverseProxy.Client.Hackney)

	on_exit(fn ->
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], client)
	end)

	conn = ReverseProxy.call(conn, "http://httpbin.org/stream-bytes/10")

	assert byte_size(conn.resp_body) == 10
	assert conn.state == :chunked
	assert conn.status == 200
	end

	test "with tesla client with gun adapter", %{conn: conn} do
	client = Pleroma.Config.get([Pleroma.ReverseProxy.Client])
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], Pleroma.ReverseProxy.Client.Tesla)
	adapter = Application.get_env(:tesla, :adapter)
	Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)

	api = Pleroma.Config.get([Pleroma.Gun.API])
	Pleroma.Config.put([Pleroma.Gun.API], :gun)
	{:ok, _} = Pleroma.Gun.Connections.start_link(Pleroma.Gun.Connections)

	conn = ReverseProxy.call(conn, "http://httpbin.org/stream-bytes/10")

	assert byte_size(conn.resp_body) == 10
	assert conn.state == :chunked
	assert conn.status == 200

	on_exit(fn ->
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], client)
	Application.put_env(:tesla, :adapter, adapter)
	Pleroma.Config.put([Pleroma.Gun.API], api)
	end)
	end

	test "with tesla client with gun adapter with ssl", %{conn: conn} do
	client = Pleroma.Config.get([Pleroma.ReverseProxy.Client])
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], Pleroma.ReverseProxy.Client.Tesla)
	adapter = Application.get_env(:tesla, :adapter)
	Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)

	api = Pleroma.Config.get([Pleroma.Gun.API])
	Pleroma.Config.put([Pleroma.Gun.API], :gun)
	{:ok, _} = Pleroma.Gun.Connections.start_link(Pleroma.Gun.Connections)

	conn = ReverseProxy.call(conn, "https://httpbin.org/stream-bytes/10")

	assert byte_size(conn.resp_body) == 10
	assert conn.state == :chunked
	assert conn.status == 200

	on_exit(fn ->
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], client)
	Application.put_env(:tesla, :adapter, adapter)
	Pleroma.Config.put([Pleroma.Gun.API], api)
	end)
	end

	test "tesla client with gun client follow redirects", %{conn: conn} do
	client = Pleroma.Config.get([Pleroma.ReverseProxy.Client])
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], Pleroma.ReverseProxy.Client.Tesla)
	adapter = Application.get_env(:tesla, :adapter)
	Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)

	api = Pleroma.Config.get([Pleroma.Gun.API])
	Pleroma.Config.put([Pleroma.Gun.API], :gun)
	{:ok, _} = Pleroma.Gun.Connections.start_link(Pleroma.Gun.Connections)

	- conn = ReverseProxy.call(conn, "https://httpbin.org/redirect/7")
	+ conn = ReverseProxy.call(conn, "https://httpbin.org/redirect/5")

	- assert byte_size(conn.resp_body) == 10
	assert conn.state == :chunked
	assert conn.status == 200

	on_exit(fn ->
	Pleroma.Config.put([Pleroma.ReverseProxy.Client], client)
	Application.put_env(:tesla, :adapter, adapter)
	Pleroma.Config.put([Pleroma.Gun.API], api)
	end)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jan 20, 1:16 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 973705
Default Alt Text: (51 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions