Fix the remaining reverse proxy tests which are still relevant

All tests related to streaming/chunking have been removed

test/pleroma/reverse_proxy_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.ReverseProxyTest do
   use Pleroma.Web.ConnCase
   import ExUnit.CaptureLog
-  import Mox
 
   alias Pleroma.ReverseProxy
   alias Plug.Conn
@@ -23,11 +22,12 @@ defmodule Pleroma.ReverseProxyTest do
 
       conn = ReverseProxy.call(conn, url)
 
-      assert conn.status == 200
+      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
+      # 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} ->
@@ -44,20 +44,18 @@ defmodule Pleroma.ReverseProxyTest do
 
       assert response(conn, 200)
     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
   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) =~
@@ -73,9 +71,12 @@ defmodule Pleroma.ReverseProxyTest do
 
   describe "HEAD requests" do
     test "common", %{conn: conn} do
-      ClientMock
+      Tesla.Mock.mock(fn %{method: :head, url: "/head"} ->
-      |> expect(:request, fn :head, "/head", _, _, _ ->
+        %Tesla.Env{
-        {:ok, 200, [{"content-type", "text/html; charset=utf-8"}]}
+          status: 200,
+          headers: [{"content-type", "text/html; charset=utf-8"}],
+          body: ""
+        }
       end)
 
       conn = ReverseProxy.call(Map.put(conn, :method, "HEAD"), "/head")
@@ -87,6 +88,13 @@ defmodule Pleroma.ReverseProxyTest 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"
 
@@ -99,6 +107,13 @@ defmodule Pleroma.ReverseProxyTest do
     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"
 
@@ -109,6 +124,13 @@ defmodule Pleroma.ReverseProxyTest do
     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) =~
@@ -120,9 +142,14 @@ defmodule Pleroma.ReverseProxyTest do
   end
 
   describe "keep request headers" do
-    # setup [:headers_mock]
-
     test "header passes", %{conn: conn} do
+      Tesla.Mock.mock(fn %{url: "/headers"} ->
+        %Tesla.Env{
+          status: 200,
+          body: ""
+        }
+      end)
+
       conn =
         Conn.put_req_header(
           conn,
@@ -131,48 +158,79 @@ defmodule Pleroma.ReverseProxyTest do
         )
         |> ReverseProxy.call("/headers")
 
-      %{"headers" => headers} = json_response(conn, 200)
+      assert response(conn, 200)
-      assert headers["Accept"] == "text/html"
+      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", "*"}
+      ]
+
+      Tesla.Mock.mock(fn %{url: "/headers", headers: ^wanted_headers} ->
+        %Tesla.Env{
+          status: 200,
+          body: ""
+        }
+      end)
+
       conn =
-        Conn.put_req_header(
+        conn
-          conn,
+        |> Conn.put_req_header("accept-language", "en-US")
-          "accept-language",
+        |> Conn.put_req_header("accept-encoding", "*")
-          "en-US"
-        )
         |> ReverseProxy.call("/headers")
 
-      %{"headers" => headers} = json_response(conn, 200)
+      assert response(conn, 200)
-      refute headers["Accept-Language"]
     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 conn.status == 400
+    assert response(conn, 400)
   end
 
-  describe "cache resp headers" do
+  describe "cache resp headers not filtered" do
     test "add cache-control", %{conn: conn} do
-      ClientMock
+      Tesla.Mock.mock(fn %{url: "/cache"} ->
-      |> expect(:request, fn :get, "/cache", _, _, _ ->
+        %Tesla.Env{
-        {:ok, 200, [{"ETag", "some ETag"}], %{}}
+          status: 200,
+          headers: [
+            {"cache-control", "public, max-age=1209600"},
+            {"etag", "some ETag"},
+            {"expires", "Wed, 21 Oct 2015 07:28:00 GMT"}
+          ],
+          body: ""
+        }
       end)
-      |> expect(:stream_body, fn _ -> :done 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 atachment", %{conn: conn} do
+    test "not attachment", %{conn: conn} do
-      # disposition_headers_mock([
+      Tesla.Mock.mock(fn %{url: "/disposition"} ->
-      #  {"content-type", "image/gif"},
+        %Tesla.Env{
-      #  {"content-length", "0"}
+          status: 200,
-      # ])
+          headers: [
+            {"content-type", "image/gif"},
+            {"content-length", "0"}
+          ],
+          body: ""
+        }
+      end)
 
       conn = ReverseProxy.call(conn, "/disposition")
 
@@ -180,10 +238,16 @@ defmodule Pleroma.ReverseProxyTest do
     end
 
     test "with content-disposition header", %{conn: conn} do
-      # disposition_headers_mock([
+      Tesla.Mock.mock(fn %{url: "/disposition"} ->
-      #  {"content-disposition", "attachment; filename=\"filename.jpg\""},
+        %Tesla.Env{
-      #  {"content-length", "0"}
+          status: 200,
-      # ])
+          headers: [
+            {"content-disposition", "attachment; filename=\"filename.jpg\""},
+            {"content-length", "0"}
+          ],
+          body: ""
+        }
+      end)
 
       conn = ReverseProxy.call(conn, "/disposition")