1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.ReverseProxyTest do
6 use Pleroma.Web.ConnCase, async: true
8 import ExUnit.CaptureLog
11 alias Pleroma.ReverseProxy
12 alias Pleroma.ReverseProxy.ClientMock
16 {:ok, _} = Registry.start_link(keys: :unique, name: ClientMock)
20 setup :verify_on_exit!
22 defp user_agent_mock(user_agent, invokes) do
23 json = Jason.encode!(%{"user-agent": user_agent})
26 |> expect(:request, fn :get, url, _, _, _ ->
27 Registry.register(ClientMock, url, 0)
31 {"content-type", "application/json"},
32 {"content-length", byte_size(json) |> to_string()}
35 |> expect(:stream_body, invokes, fn %{url: url} = client ->
36 case Registry.lookup(ClientMock, url) do
38 Registry.update_value(ClientMock, url, &(&1 + 1))
42 Registry.unregister(ClientMock, url)
48 describe "reverse proxy" do
49 test "do not track successful request", %{conn: conn} do
50 user_agent_mock("hackney/1.15.1", 2)
53 conn = ReverseProxy.call(conn, url)
55 assert conn.status == 200
56 assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, nil}
60 describe "user-agent" do
61 test "don't keep", %{conn: conn} do
62 user_agent_mock("hackney/1.15.1", 2)
63 conn = ReverseProxy.call(conn, "/user-agent")
64 assert json_response(conn, 200) == %{"user-agent" => "hackney/1.15.1"}
67 test "keep", %{conn: conn} do
68 user_agent_mock(Pleroma.Application.user_agent(), 2)
69 conn = ReverseProxy.call(conn, "/user-agent-keep", keep_user_agent: true)
70 assert json_response(conn, 200) == %{"user-agent" => Pleroma.Application.user_agent()}
74 test "closed connection", %{conn: conn} do
76 |> expect(:request, fn :get, "/closed", _, _, _ -> {:ok, 200, [], %{}} end)
77 |> expect(:stream_body, fn _ -> {:error, :closed} end)
78 |> expect(:close, fn _ -> :ok end)
80 conn = ReverseProxy.call(conn, "/closed")
84 defp stream_mock(invokes, with_close? \\ false) do
86 |> expect(:request, fn :get, "/stream-bytes/" <> length, _, _, _ ->
87 Registry.register(ClientMock, "/stream-bytes/" <> length, 0)
89 {:ok, 200, [{"content-type", "application/octet-stream"}],
90 %{url: "/stream-bytes/" <> length}}
92 |> expect(:stream_body, invokes, fn %{url: "/stream-bytes/" <> length} = client ->
93 max = String.to_integer(length)
95 case Registry.lookup(ClientMock, "/stream-bytes/" <> length) do
96 [{_, current}] when current < max ->
97 Registry.update_value(
99 "/stream-bytes/" <> length,
103 {:ok, "0123456789", client}
106 Registry.unregister(ClientMock, "/stream-bytes/" <> length)
112 expect(ClientMock, :close, fn _ -> :ok end)
116 describe "max_body" do
117 test "length returns error if content-length more than option", %{conn: conn} do
118 user_agent_mock("hackney/1.15.1", 0)
120 assert capture_log(fn ->
121 ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
123 "[error] Elixir.Pleroma.ReverseProxy: request to \"/huge-file\" failed: :body_too_large"
125 assert {:ok, true} == Cachex.get(:failed_proxy_url_cache, "/huge-file")
127 assert capture_log(fn ->
128 ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
132 test "max_body_length returns error if streaming body more than that option", %{conn: conn} do
135 assert capture_log(fn ->
136 ReverseProxy.call(conn, "/stream-bytes/50", max_body_length: 30)
138 "[warn] Elixir.Pleroma.ReverseProxy request to /stream-bytes/50 failed while reading/chunking: :body_too_large"
142 describe "HEAD requests" do
143 test "common", %{conn: conn} do
145 |> expect(:request, fn :head, "/head", _, _, _ ->
146 {:ok, 200, [{"content-type", "text/html; charset=utf-8"}]}
149 conn = ReverseProxy.call(Map.put(conn, :method, "HEAD"), "/head")
150 assert html_response(conn, 200) == ""
154 defp error_mock(status) when is_integer(status) do
156 |> expect(:request, fn :get, "/status/" <> _, _, _, _ ->
161 describe "returns error on" do
162 test "500", %{conn: conn} do
166 capture_log(fn -> ReverseProxy.call(conn, url) end) =~
167 "[error] Elixir.Pleroma.ReverseProxy: request to /status/500 failed with HTTP status 500"
169 assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
171 {:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
175 test "400", %{conn: conn} do
179 capture_log(fn -> ReverseProxy.call(conn, url) end) =~
180 "[error] Elixir.Pleroma.ReverseProxy: request to /status/400 failed with HTTP status 400"
182 assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
183 assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
186 test "403", %{conn: conn} do
191 ReverseProxy.call(conn, url, failed_request_ttl: :timer.seconds(120))
193 "[error] Elixir.Pleroma.ReverseProxy: request to /status/403 failed with HTTP status 403"
195 {:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
199 test "204", %{conn: conn} do
201 expect(ClientMock, :request, fn :get, _url, _, _, _ -> {:ok, 204, [], %{}} end)
204 conn = ReverseProxy.call(conn, url)
205 assert conn.resp_body == "Request failed: No Content"
208 "[error] Elixir.Pleroma.ReverseProxy: request to \"/status/204\" failed with HTTP status 204"
210 assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
211 assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
215 test "streaming", %{conn: conn} do
217 conn = ReverseProxy.call(conn, "/stream-bytes/200")
218 assert conn.state == :chunked
219 assert byte_size(conn.resp_body) == 200
220 assert Conn.get_resp_header(conn, "content-type") == ["application/octet-stream"]
223 defp headers_mock(_) do
225 |> expect(:request, fn :get, "/headers", headers, _, _ ->
226 Registry.register(ClientMock, "/headers", 0)
227 {:ok, 200, [{"content-type", "application/json"}], %{url: "/headers", headers: headers}}
229 |> expect(:stream_body, 2, fn %{url: url, headers: headers} = client ->
230 case Registry.lookup(ClientMock, url) do
232 Registry.update_value(ClientMock, url, &(&1 + 1))
233 headers = for {k, v} <- headers, into: %{}, do: {String.capitalize(k), v}
234 {:ok, Jason.encode!(%{headers: headers}), client}
237 Registry.unregister(ClientMock, url)
245 describe "keep request headers" do
246 setup [:headers_mock]
248 test "header passes", %{conn: conn} do
255 |> ReverseProxy.call("/headers")
257 %{"headers" => headers} = json_response(conn, 200)
258 assert headers["Accept"] == "text/html"
261 test "header is filtered", %{conn: conn} do
268 |> ReverseProxy.call("/headers")
270 %{"headers" => headers} = json_response(conn, 200)
271 refute headers["Accept-Language"]
275 test "returns 400 on non GET, HEAD requests", %{conn: conn} do
276 conn = ReverseProxy.call(Map.put(conn, :method, "POST"), "/ip")
277 assert conn.status == 400
280 describe "cache resp headers" do
281 test "add cache-control", %{conn: conn} do
283 |> expect(:request, fn :get, "/cache", _, _, _ ->
284 {:ok, 200, [{"ETag", "some ETag"}], %{}}
286 |> expect(:stream_body, fn _ -> :done end)
288 conn = ReverseProxy.call(conn, "/cache")
289 assert {"cache-control", "public, max-age=1209600"} in conn.resp_headers
293 defp disposition_headers_mock(headers) do
295 |> expect(:request, fn :get, "/disposition", _, _, _ ->
296 Registry.register(ClientMock, "/disposition", 0)
298 {:ok, 200, headers, %{url: "/disposition"}}
300 |> expect(:stream_body, 2, fn %{url: "/disposition"} = client ->
301 case Registry.lookup(ClientMock, "/disposition") do
303 Registry.update_value(ClientMock, "/disposition", &(&1 + 1))
307 Registry.unregister(ClientMock, "/disposition")
313 describe "response content disposition header" do
314 test "not atachment", %{conn: conn} do
315 disposition_headers_mock([
316 {"content-type", "image/gif"},
317 {"content-length", "0"}
320 conn = ReverseProxy.call(conn, "/disposition")
322 assert {"content-type", "image/gif"} in conn.resp_headers
325 test "with content-disposition header", %{conn: conn} do
326 disposition_headers_mock([
327 {"content-disposition", "attachment; filename=\"filename.jpg\""},
328 {"content-length", "0"}
331 conn = ReverseProxy.call(conn, "/disposition")
333 assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers