1 defmodule Pleroma.ReverseProxyTest do
2 use Pleroma.Web.ConnCase, async: true
3 import ExUnit.CaptureLog
4 import ExUnit.CaptureLog
6 alias Pleroma.ReverseProxy
7 alias Pleroma.ReverseProxy.ClientMock
10 {:ok, _} = Registry.start_link(keys: :unique, name: Pleroma.ReverseProxy.ClientMock)
14 setup :verify_on_exit!
16 defp user_agent_mock(user_agent, invokes) do
17 json = Jason.encode!(%{"user-agent": user_agent})
20 |> expect(:request, fn :get, url, _, _, _ ->
21 Registry.register(Pleroma.ReverseProxy.ClientMock, url, 0)
25 {"content-type", "application/json"},
26 {"content-length", byte_size(json) |> to_string()}
29 |> expect(:stream_body, invokes, fn %{url: url} ->
30 case Registry.lookup(Pleroma.ReverseProxy.ClientMock, url) do
32 Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
36 Registry.unregister(Pleroma.ReverseProxy.ClientMock, url)
42 describe "user-agent" do
43 test "don't keep", %{conn: conn} do
44 user_agent_mock("hackney/1.15.1", 2)
45 conn = ReverseProxy.call(conn, "/user-agent")
46 assert json_response(conn, 200) == %{"user-agent" => "hackney/1.15.1"}
49 test "keep", %{conn: conn} do
50 user_agent_mock(Pleroma.Application.user_agent(), 2)
51 conn = ReverseProxy.call(conn, "/user-agent-keep", keep_user_agent: true)
52 assert json_response(conn, 200) == %{"user-agent" => Pleroma.Application.user_agent()}
56 test "closed connection", %{conn: conn} do
58 |> expect(:request, fn :get, "/closed", _, _, _ -> {:ok, 200, [], %{}} end)
59 |> expect(:stream_body, fn _ -> {:error, :closed} end)
60 |> expect(:close, fn _ -> :ok end)
62 conn = ReverseProxy.call(conn, "/closed")
66 describe "max_body " do
67 test "length returns error if content-length more than option", %{conn: conn} do
68 user_agent_mock("hackney/1.15.1", 0)
70 assert capture_log(fn ->
71 ReverseProxy.call(conn, "/user-agent", max_body_length: 4)
73 "[error] Elixir.Pleroma.ReverseProxy: request to \"/user-agent\" failed: :body_too_large"
76 defp stream_mock(invokes, with_close? \\ false) do
78 |> expect(:request, fn :get, "/stream-bytes/" <> length, _, _, _ ->
79 Registry.register(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length, 0)
81 {:ok, 200, [{"content-type", "application/octet-stream"}],
82 %{url: "/stream-bytes/" <> length}}
84 |> expect(:stream_body, invokes, fn %{url: "/stream-bytes/" <> length} ->
85 max = String.to_integer(length)
87 case Registry.lookup(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length) do
88 [{_, current}] when current < max ->
89 Registry.update_value(
90 Pleroma.ReverseProxy.ClientMock,
91 "/stream-bytes/" <> length,
98 Registry.unregister(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length)
104 expect(ClientMock, :close, fn _ -> :ok end)
108 test "max_body_size returns error if streaming body more than that option", %{conn: conn} do
111 assert capture_log(fn ->
112 ReverseProxy.call(conn, "/stream-bytes/50", max_body_size: 30)
114 "[warn] Elixir.Pleroma.ReverseProxy request to /stream-bytes/50 failed while reading/chunking: :body_too_large"
118 describe "HEAD requests" do
119 test "common", %{conn: conn} do
121 |> expect(:request, fn :head, "/head", _, _, _ ->
122 {:ok, 200, [{"content-type", "text/html; charset=utf-8"}]}
125 conn = ReverseProxy.call(Map.put(conn, :method, "HEAD"), "/head")
126 assert html_response(conn, 200) == ""
130 defp error_mock(status) when is_integer(status) do
132 |> expect(:request, fn :get, "/status/" <> _, _, _, _ ->
137 describe "returns error on" do
138 test "500", %{conn: conn} do
141 capture_log(fn -> ReverseProxy.call(conn, "/status/500") end) =~
142 "[error] Elixir.Pleroma.ReverseProxy: request to /status/500 failed with HTTP status 500"
145 test "400", %{conn: conn} do
148 capture_log(fn -> ReverseProxy.call(conn, "/status/400") end) =~
149 "[error] Elixir.Pleroma.ReverseProxy: request to /status/400 failed with HTTP status 400"
152 test "204", %{conn: conn} do
154 |> expect(:request, fn :get, "/status/204", _, _, _ -> {:ok, 204, [], %{}} end)
157 conn = ReverseProxy.call(conn, "/status/204")
158 assert conn.resp_body == "Request failed: No Content"
161 "[error] Elixir.Pleroma.ReverseProxy: request to \"/status/204\" failed with HTTP status 204"
165 test "streaming", %{conn: conn} do
167 conn = ReverseProxy.call(conn, "/stream-bytes/200")
168 assert conn.state == :chunked
169 assert byte_size(conn.resp_body) == 200
170 assert Plug.Conn.get_resp_header(conn, "content-type") == ["application/octet-stream"]
173 defp headers_mock(_) do
175 |> expect(:request, fn :get, "/headers", headers, _, _ ->
176 Registry.register(Pleroma.ReverseProxy.ClientMock, "/headers", 0)
177 {:ok, 200, [{"content-type", "application/json"}], %{url: "/headers", headers: headers}}
179 |> expect(:stream_body, 2, fn %{url: url, headers: headers} ->
180 case Registry.lookup(Pleroma.ReverseProxy.ClientMock, url) do
182 Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
183 headers = for {k, v} <- headers, into: %{}, do: {String.capitalize(k), v}
184 {:ok, Jason.encode!(%{headers: headers})}
187 Registry.unregister(Pleroma.ReverseProxy.ClientMock, url)
195 describe "keep request headers" do
196 setup [:headers_mock]
198 test "header passes", %{conn: conn} do
200 Plug.Conn.put_req_header(
205 |> ReverseProxy.call("/headers")
207 %{"headers" => headers} = json_response(conn, 200)
208 assert headers["Accept"] == "text/html"
211 test "header is filtered", %{conn: conn} do
213 Plug.Conn.put_req_header(
218 |> ReverseProxy.call("/headers")
220 %{"headers" => headers} = json_response(conn, 200)
221 refute headers["Accept-Language"]
225 test "returns 400 on non GET, HEAD requests", %{conn: conn} do
226 conn = ReverseProxy.call(Map.put(conn, :method, "POST"), "/ip")
227 assert conn.status == 400
230 describe "cache resp headers" do
231 test "returns headers", %{conn: conn} do
233 |> expect(:request, fn :get, "/cache/" <> ttl, _, _, _ ->
234 {:ok, 200, [{"cache-control", "public, max-age=" <> ttl}], %{}}
236 |> expect(:stream_body, fn _ -> :done end)
238 conn = ReverseProxy.call(conn, "/cache/10")
239 assert {"cache-control", "public, max-age=10"} in conn.resp_headers
242 test "add cache-control", %{conn: conn} do
244 |> expect(:request, fn :get, "/cache", _, _, _ ->
245 {:ok, 200, [{"ETag", "some ETag"}], %{}}
247 |> expect(:stream_body, fn _ -> :done end)
249 conn = ReverseProxy.call(conn, "/cache")
250 assert {"cache-control", "public"} in conn.resp_headers
254 defp disposition_headers_mock(headers) do
256 |> expect(:request, fn :get, "/disposition", _, _, _ ->
257 Registry.register(Pleroma.ReverseProxy.ClientMock, "/disposition", 0)
259 {:ok, 200, headers, %{url: "/disposition"}}
261 |> expect(:stream_body, 2, fn %{url: "/disposition"} ->
262 case Registry.lookup(Pleroma.ReverseProxy.ClientMock, "/disposition") do
264 Registry.update_value(Pleroma.ReverseProxy.ClientMock, "/disposition", &(&1 + 1))
268 Registry.unregister(Pleroma.ReverseProxy.ClientMock, "/disposition")
274 describe "response content disposition header" do
275 test "not atachment", %{conn: conn} do
276 disposition_headers_mock([
277 {"content-type", "image/gif"},
278 {"content-length", 0}
281 conn = ReverseProxy.call(conn, "/disposition")
283 assert {"content-type", "image/gif"} in conn.resp_headers
286 test "with content-disposition header", %{conn: conn} do
287 disposition_headers_mock([
288 {"content-disposition", "attachment; filename=\"filename.jpg\""},
289 {"content-length", 0}
292 conn = ReverseProxy.call(conn, "/disposition")
294 assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers