Git of dcc - anni/blob - test/pleroma/reverse_proxy_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.ReverseProxyTest do
   6   use Pleroma.Web.ConnCase
   7   import ExUnit.CaptureLog
   8   import Mox
   9
  10   alias Pleroma.ReverseProxy
  11   alias Pleroma.ReverseProxy.ClientMock
  12   alias Plug.Conn
  13
  14   setup_all do
  15     {:ok, _} = Registry.start_link(keys: :unique, name: ClientMock)
  16     :ok
  17   end
  18
  19   setup :verify_on_exit!
  20
  21   defp request_mock(invokes) do
  22     ClientMock
  23     |> expect(:request, fn :get, url, headers, _body, _opts ->
  24       Registry.register(ClientMock, url, 0)
  25       body = headers |> Enum.into(%{}) |> Jason.encode!()
  26
  27       {:ok, 200,
  28        [
  29          {"content-type", "application/json"},
  30          {"content-length", byte_size(body) |> to_string()}
  31        ], %{url: url, body: body}}
  32     end)
  33     |> expect(:stream_body, invokes, fn %{url: url, body: body} = client ->
  34       case Registry.lookup(ClientMock, url) do
  35         [{_, 0}] ->
  36           Registry.update_value(ClientMock, url, &(&1 + 1))
  37           {:ok, body, client}
  38
  39         [{_, 1}] ->
  40           Registry.unregister(ClientMock, url)
  41           :done
  42       end
  43     end)
  44   end
  45
  46   describe "reverse proxy" do
  47     test "do not track successful request", %{conn: conn} do
  48       request_mock(2)
  49       url = "/success"
  50
  51       conn = ReverseProxy.call(conn, url)
  52
  53       assert conn.status == 200
  54       assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, nil}
  55     end
  56   end
  57
  58   test "use Pleroma's user agent in the request; don't pass the client's", %{conn: conn} do
  59     request_mock(2)
  60
  61     conn =
  62       conn
  63       |> Plug.Conn.put_req_header("user-agent", "fake/1.0")
  64       |> ReverseProxy.call("/user-agent")
  65
  66     assert json_response(conn, 200) == %{"user-agent" => Pleroma.Application.user_agent()}
  67   end
  68
  69   test "closed connection", %{conn: conn} do
  70     ClientMock
  71     |> expect(:request, fn :get, "/closed", _, _, _ -> {:ok, 200, [], %{}} end)
  72     |> expect(:stream_body, fn _ -> {:error, :closed} end)
  73     |> expect(:close, fn _ -> :ok end)
  74
  75     conn = ReverseProxy.call(conn, "/closed")
  76     assert conn.halted
  77   end
  78
  79   defp stream_mock(invokes, with_close? \\ false) do
  80     ClientMock
  81     |> expect(:request, fn :get, "/stream-bytes/" <> length, _, _, _ ->
  82       Registry.register(ClientMock, "/stream-bytes/" <> length, 0)
  83
  84       {:ok, 200, [{"content-type", "application/octet-stream"}],
  85        %{url: "/stream-bytes/" <> length}}
  86     end)
  87     |> expect(:stream_body, invokes, fn %{url: "/stream-bytes/" <> length} = client ->
  88       max = String.to_integer(length)
  89
  90       case Registry.lookup(ClientMock, "/stream-bytes/" <> length) do
  91         [{_, current}] when current < max ->
  92           Registry.update_value(
  93             ClientMock,
  94             "/stream-bytes/" <> length,
  95             &(&1 + 10)
  96           )
  97
  98           {:ok, "0123456789", client}
  99
 100         [{_, ^max}] ->
 101           Registry.unregister(ClientMock, "/stream-bytes/" <> length)
 102           :done
 103       end
 104     end)
 105
 106     if with_close? do
 107       expect(ClientMock, :close, fn _ -> :ok end)
 108     end
 109   end
 110
 111   describe "max_body" do
 112     test "length returns error if content-length more than option", %{conn: conn} do
 113       request_mock(0)
 114
 115       assert capture_log(fn ->
 116                ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
 117              end) =~
 118                "[error] Elixir.Pleroma.ReverseProxy: request to \"/huge-file\" failed: :body_too_large"
 119
 120       assert {:ok, true} == Cachex.get(:failed_proxy_url_cache, "/huge-file")
 121
 122       assert capture_log(fn ->
 123                ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
 124              end) == ""
 125     end
 126
 127     test "max_body_length returns error if streaming body more than that option", %{conn: conn} do
 128       stream_mock(3, true)
 129
 130       assert capture_log(fn ->
 131                ReverseProxy.call(conn, "/stream-bytes/50", max_body_length: 30)
 132              end) =~
 133                "Elixir.Pleroma.ReverseProxy request to /stream-bytes/50 failed while reading/chunking: :body_too_large"
 134     end
 135   end
 136
 137   describe "HEAD requests" do
 138     test "common", %{conn: conn} do
 139       ClientMock
 140       |> expect(:request, fn :head, "/head", _, _, _ ->
 141         {:ok, 200, [{"content-type", "text/html; charset=utf-8"}]}
 142       end)
 143
 144       conn = ReverseProxy.call(Map.put(conn, :method, "HEAD"), "/head")
 145       assert html_response(conn, 200) == ""
 146     end
 147   end
 148
 149   defp error_mock(status) when is_integer(status) do
 150     ClientMock
 151     |> expect(:request, fn :get, "/status/" <> _, _, _, _ ->
 152       {:error, status}
 153     end)
 154   end
 155
 156   describe "returns error on" do
 157     test "500", %{conn: conn} do
 158       error_mock(500)
 159       url = "/status/500"
 160
 161       capture_log(fn -> ReverseProxy.call(conn, url) end) =~
 162         "[error] Elixir.Pleroma.ReverseProxy: request to /status/500 failed with HTTP status 500"
 163
 164       assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
 165
 166       {:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
 167       assert ttl <= 60_000
 168     end
 169
 170     test "400", %{conn: conn} do
 171       error_mock(400)
 172       url = "/status/400"
 173
 174       capture_log(fn -> ReverseProxy.call(conn, url) end) =~
 175         "[error] Elixir.Pleroma.ReverseProxy: request to /status/400 failed with HTTP status 400"
 176
 177       assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
 178       assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
 179     end
 180
 181     test "403", %{conn: conn} do
 182       error_mock(403)
 183       url = "/status/403"
 184
 185       capture_log(fn ->
 186         ReverseProxy.call(conn, url, failed_request_ttl: :timer.seconds(120))
 187       end) =~
 188         "[error] Elixir.Pleroma.ReverseProxy: request to /status/403 failed with HTTP status 403"
 189
 190       {:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
 191       assert ttl > 100_000
 192     end
 193
 194     test "204", %{conn: conn} do
 195       url = "/status/204"
 196       expect(ClientMock, :request, fn :get, _url, _, _, _ -> {:ok, 204, [], %{}} end)
 197
 198       capture_log(fn ->
 199         conn = ReverseProxy.call(conn, url)
 200         assert conn.resp_body == "Request failed: No Content"
 201         assert conn.halted
 202       end) =~
 203         "[error] Elixir.Pleroma.ReverseProxy: request to \"/status/204\" failed with HTTP status 204"
 204
 205       assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
 206       assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
 207     end
 208   end
 209
 210   test "streaming", %{conn: conn} do
 211     stream_mock(21)
 212     conn = ReverseProxy.call(conn, "/stream-bytes/200")
 213     assert conn.state == :chunked
 214     assert byte_size(conn.resp_body) == 200
 215     assert Conn.get_resp_header(conn, "content-type") == ["application/octet-stream"]
 216   end
 217
 218   defp headers_mock(_) do
 219     ClientMock
 220     |> expect(:request, fn :get, "/headers", headers, _, _ ->
 221       Registry.register(ClientMock, "/headers", 0)
 222       {:ok, 200, [{"content-type", "application/json"}], %{url: "/headers", headers: headers}}
 223     end)
 224     |> expect(:stream_body, 2, fn %{url: url, headers: headers} = client ->
 225       case Registry.lookup(ClientMock, url) do
 226         [{_, 0}] ->
 227           Registry.update_value(ClientMock, url, &(&1 + 1))
 228           headers = for {k, v} <- headers, into: %{}, do: {String.capitalize(k), v}
 229           {:ok, Jason.encode!(%{headers: headers}), client}
 230
 231         [{_, 1}] ->
 232           Registry.unregister(ClientMock, url)
 233           :done
 234       end
 235     end)
 236
 237     :ok
 238   end
 239
 240   describe "keep request headers" do
 241     setup [:headers_mock]
 242
 243     test "header passes", %{conn: conn} do
 244       conn =
 245         Conn.put_req_header(
 246           conn,
 247           "accept",
 248           "text/html"
 249         )
 250         |> ReverseProxy.call("/headers")
 251
 252       %{"headers" => headers} = json_response(conn, 200)
 253       assert headers["Accept"] == "text/html"
 254     end
 255
 256     test "header is filtered", %{conn: conn} do
 257       conn =
 258         Conn.put_req_header(
 259           conn,
 260           "accept-language",
 261           "en-US"
 262         )
 263         |> ReverseProxy.call("/headers")
 264
 265       %{"headers" => headers} = json_response(conn, 200)
 266       refute headers["Accept-Language"]
 267     end
 268   end
 269
 270   test "returns 400 on non GET, HEAD requests", %{conn: conn} do
 271     conn = ReverseProxy.call(Map.put(conn, :method, "POST"), "/ip")
 272     assert conn.status == 400
 273   end
 274
 275   describe "cache resp headers" do
 276     test "add cache-control", %{conn: conn} do
 277       ClientMock
 278       |> expect(:request, fn :get, "/cache", _, _, _ ->
 279         {:ok, 200, [{"ETag", "some ETag"}], %{}}
 280       end)
 281       |> expect(:stream_body, fn _ -> :done end)
 282
 283       conn = ReverseProxy.call(conn, "/cache")
 284       assert {"cache-control", "public, max-age=1209600"} in conn.resp_headers
 285     end
 286   end
 287
 288   defp disposition_headers_mock(headers) do
 289     ClientMock
 290     |> expect(:request, fn :get, "/disposition", _, _, _ ->
 291       Registry.register(ClientMock, "/disposition", 0)
 292
 293       {:ok, 200, headers, %{url: "/disposition"}}
 294     end)
 295     |> expect(:stream_body, 2, fn %{url: "/disposition"} = client ->
 296       case Registry.lookup(ClientMock, "/disposition") do
 297         [{_, 0}] ->
 298           Registry.update_value(ClientMock, "/disposition", &(&1 + 1))
 299           {:ok, "", client}
 300
 301         [{_, 1}] ->
 302           Registry.unregister(ClientMock, "/disposition")
 303           :done
 304       end
 305     end)
 306   end
 307
 308   describe "response content disposition header" do
 309     test "not atachment", %{conn: conn} do
 310       disposition_headers_mock([
 311         {"content-type", "image/gif"},
 312         {"content-length", "0"}
 313       ])
 314
 315       conn = ReverseProxy.call(conn, "/disposition")
 316
 317       assert {"content-type", "image/gif"} in conn.resp_headers
 318     end
 319
 320     test "with content-disposition header", %{conn: conn} do
 321       disposition_headers_mock([
 322         {"content-disposition", "attachment; filename=\"filename.jpg\""},
 323         {"content-length", "0"}
 324       ])
 325
 326       conn = ReverseProxy.call(conn, "/disposition")
 327
 328       assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
 329     end
 330   end
 331 end