From 514c899275a32e6ef63305f9424c50344d41b12e Mon Sep 17 00:00:00 2001
From: Alexander Strizhakov <alex.strizhakov@gmail.com>
Date: Tue, 11 Feb 2020 10:12:57 +0300
Subject: adding gun adapter

---
 test/reverse_proxy/reverse_proxy_test.exs | 385 ++++++++++++++++++++++++++++++
 1 file changed, 385 insertions(+)
 create mode 100644 test/reverse_proxy/reverse_proxy_test.exs

(limited to 'test/reverse_proxy/reverse_proxy_test.exs')

diff --git a/test/reverse_proxy/reverse_proxy_test.exs b/test/reverse_proxy/reverse_proxy_test.exs
new file mode 100644
index 000000000..1ab3cc4bb
--- /dev/null
+++ b/test/reverse_proxy/reverse_proxy_test.exs
@@ -0,0 +1,385 @@
+# 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 "reverse proxy" do
+    test "do not track successful request", %{conn: conn} do
+      user_agent_mock("hackney/1.15.1", 2)
+      url = "/success"
+
+      conn = ReverseProxy.call(conn, url)
+
+      assert conn.status == 200
+      assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, nil}
+    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, "/huge-file", max_body_length: 4)
+             end) =~
+               "[error] Elixir.Pleroma.ReverseProxy: request to \"/huge-file\" failed: :body_too_large"
+
+      assert {:ok, true} == Cachex.get(:failed_proxy_url_cache, "/huge-file")
+
+      assert capture_log(fn ->
+               ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
+             end) == ""
+    end
+
+    test "max_body_length 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_length: 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)
+      url = "/status/500"
+
+      capture_log(fn -> ReverseProxy.call(conn, url) end) =~
+        "[error] Elixir.Pleroma.ReverseProxy: request to /status/500 failed with HTTP status 500"
+
+      assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
+
+      {:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
+      assert ttl <= 60_000
+    end
+
+    test "400", %{conn: conn} do
+      error_mock(400)
+      url = "/status/400"
+
+      capture_log(fn -> ReverseProxy.call(conn, url) end) =~
+        "[error] Elixir.Pleroma.ReverseProxy: request to /status/400 failed with HTTP status 400"
+
+      assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
+      assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
+    end
+
+    test "403", %{conn: conn} do
+      error_mock(403)
+      url = "/status/403"
+
+      capture_log(fn ->
+        ReverseProxy.call(conn, url, failed_request_ttl: :timer.seconds(120))
+      end) =~
+        "[error] Elixir.Pleroma.ReverseProxy: request to /status/403 failed with HTTP status 403"
+
+      {:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
+      assert ttl > 100_000
+    end
+
+    test "204", %{conn: conn} do
+      url = "/status/204"
+      expect(ClientMock, :request, fn :get, _url, _, _, _ -> {:ok, 204, [], %{}} end)
+
+      capture_log(fn ->
+        conn = ReverseProxy.call(conn, url)
+        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"
+
+      assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
+      assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
+    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 "tesla client using gun integration" do
+    @describetag :integration
+
+    clear_config([Pleroma.ReverseProxy.Client]) do
+      Pleroma.Config.put([Pleroma.ReverseProxy.Client], Pleroma.ReverseProxy.Client.Tesla)
+    end
+
+    clear_config([Pleroma.Gun.API]) do
+      Pleroma.Config.put([Pleroma.Gun.API], Pleroma.Gun)
+    end
+
+    setup 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)
+    end
+
+    test "common", %{conn: conn} do
+      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 "ssl", %{conn: conn} do
+      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
+    end
+
+    test "follow redirects", %{conn: conn} do
+      conn = ReverseProxy.call(conn, "https://httpbin.org/redirect/5")
+      assert conn.state == :chunked
+      assert conn.status == 200
+    end
+  end
+end
-- 
cgit v1.2.3


From ad8f26c0a4a0a579e93547e78313d3e4ecef6ed5 Mon Sep 17 00:00:00 2001
From: Alexander Strizhakov <alex.strizhakov@gmail.com>
Date: Fri, 21 Feb 2020 12:53:40 +0300
Subject: more info in Connections.checkin timout errors

---
 test/reverse_proxy/reverse_proxy_test.exs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'test/reverse_proxy/reverse_proxy_test.exs')

diff --git a/test/reverse_proxy/reverse_proxy_test.exs b/test/reverse_proxy/reverse_proxy_test.exs
index 1ab3cc4bb..f61fc02c5 100644
--- a/test/reverse_proxy/reverse_proxy_test.exs
+++ b/test/reverse_proxy/reverse_proxy_test.exs
@@ -345,12 +345,12 @@ defmodule Pleroma.ReverseProxyTest do
   describe "tesla client using gun integration" do
     @describetag :integration
 
-    clear_config([Pleroma.ReverseProxy.Client]) do
-      Pleroma.Config.put([Pleroma.ReverseProxy.Client], Pleroma.ReverseProxy.Client.Tesla)
+    clear_config(Pleroma.ReverseProxy.Client) do
+      Pleroma.Config.put(Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.Client.Tesla)
     end
 
-    clear_config([Pleroma.Gun.API]) do
-      Pleroma.Config.put([Pleroma.Gun.API], Pleroma.Gun)
+    clear_config(Pleroma.Gun.API) do
+      Pleroma.Config.put(Pleroma.Gun.API, Pleroma.Gun)
     end
 
     setup do
-- 
cgit v1.2.3


From 884d9710b209cc9981c7de61d4e95fd26cd83820 Mon Sep 17 00:00:00 2001
From: Alexander Strizhakov <alex.strizhakov@gmail.com>
Date: Tue, 3 Mar 2020 19:24:14 +0300
Subject: refactoring for gun api modules

---
 test/reverse_proxy/reverse_proxy_test.exs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'test/reverse_proxy/reverse_proxy_test.exs')

diff --git a/test/reverse_proxy/reverse_proxy_test.exs b/test/reverse_proxy/reverse_proxy_test.exs
index f61fc02c5..8e72698ee 100644
--- a/test/reverse_proxy/reverse_proxy_test.exs
+++ b/test/reverse_proxy/reverse_proxy_test.exs
@@ -349,8 +349,8 @@ defmodule Pleroma.ReverseProxyTest do
       Pleroma.Config.put(Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.Client.Tesla)
     end
 
-    clear_config(Pleroma.Gun.API) do
-      Pleroma.Config.put(Pleroma.Gun.API, Pleroma.Gun)
+    clear_config(Pleroma.Gun) do
+      Pleroma.Config.put(Pleroma.Gun, Pleroma.Gun.API)
     end
 
     setup do
-- 
cgit v1.2.3


From 931111fd5518cb79449cf79ffe29cb774c55d5ff Mon Sep 17 00:00:00 2001
From: Alexander Strizhakov <alex.strizhakov@gmail.com>
Date: Thu, 5 Mar 2020 18:57:45 +0300
Subject: removing integration tests

---
 test/reverse_proxy/reverse_proxy_test.exs | 41 -------------------------------
 1 file changed, 41 deletions(-)

(limited to 'test/reverse_proxy/reverse_proxy_test.exs')

diff --git a/test/reverse_proxy/reverse_proxy_test.exs b/test/reverse_proxy/reverse_proxy_test.exs
index 18aae5a6b..c17ab0f89 100644
--- a/test/reverse_proxy/reverse_proxy_test.exs
+++ b/test/reverse_proxy/reverse_proxy_test.exs
@@ -341,45 +341,4 @@ defmodule Pleroma.ReverseProxyTest do
       assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
     end
   end
-
-  describe "tesla client using gun integration" do
-    @describetag :integration
-
-    clear_config(Pleroma.ReverseProxy.Client) do
-      Pleroma.Config.put(Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.Client.Tesla)
-    end
-
-    clear_config(Pleroma.Gun) do
-      Pleroma.Config.put(Pleroma.Gun, Pleroma.Gun.API)
-    end
-
-    setup 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)
-    end
-
-    test "common", %{conn: conn} do
-      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 "ssl", %{conn: conn} do
-      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
-    end
-
-    test "follow redirects", %{conn: conn} do
-      conn = ReverseProxy.call(conn, "https://httpbin.org/redirect/5")
-      assert conn.state == :chunked
-      assert conn.status == 200
-    end
-  end
 end
-- 
cgit v1.2.3


From 9f884a263904c8b243507d35b29da712a31fb444 Mon Sep 17 00:00:00 2001
From: Alexander Strizhakov <alex.strizhakov@gmail.com>
Date: Sat, 7 Mar 2020 11:01:37 +0300
Subject: tests changes

---
 test/reverse_proxy/reverse_proxy_test.exs | 45 ++++++++++++++++---------------
 1 file changed, 24 insertions(+), 21 deletions(-)

(limited to 'test/reverse_proxy/reverse_proxy_test.exs')

diff --git a/test/reverse_proxy/reverse_proxy_test.exs b/test/reverse_proxy/reverse_proxy_test.exs
index c17ab0f89..abdfddcb7 100644
--- a/test/reverse_proxy/reverse_proxy_test.exs
+++ b/test/reverse_proxy/reverse_proxy_test.exs
@@ -3,14 +3,17 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.ReverseProxyTest do
-  use Pleroma.Web.ConnCase
+  use Pleroma.Web.ConnCase, async: true
+
   import ExUnit.CaptureLog
   import Mox
+
   alias Pleroma.ReverseProxy
   alias Pleroma.ReverseProxy.ClientMock
+  alias Plug.Conn
 
   setup_all do
-    {:ok, _} = Registry.start_link(keys: :unique, name: Pleroma.ReverseProxy.ClientMock)
+    {:ok, _} = Registry.start_link(keys: :unique, name: ClientMock)
     :ok
   end
 
@@ -21,7 +24,7 @@ defmodule Pleroma.ReverseProxyTest do
 
     ClientMock
     |> expect(:request, fn :get, url, _, _, _ ->
-      Registry.register(Pleroma.ReverseProxy.ClientMock, url, 0)
+      Registry.register(ClientMock, url, 0)
 
       {:ok, 200,
        [
@@ -30,13 +33,13 @@ defmodule Pleroma.ReverseProxyTest do
        ], %{url: url}}
     end)
     |> expect(:stream_body, invokes, fn %{url: url} = client ->
-      case Registry.lookup(Pleroma.ReverseProxy.ClientMock, url) do
+      case Registry.lookup(ClientMock, url) do
         [{_, 0}] ->
-          Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
+          Registry.update_value(ClientMock, url, &(&1 + 1))
           {:ok, json, client}
 
         [{_, 1}] ->
-          Registry.unregister(Pleroma.ReverseProxy.ClientMock, url)
+          Registry.unregister(ClientMock, url)
           :done
       end
     end)
@@ -81,7 +84,7 @@ defmodule Pleroma.ReverseProxyTest do
   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)
+      Registry.register(ClientMock, "/stream-bytes/" <> length, 0)
 
       {:ok, 200, [{"content-type", "application/octet-stream"}],
        %{url: "/stream-bytes/" <> length}}
@@ -89,10 +92,10 @@ defmodule Pleroma.ReverseProxyTest do
     |> 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
+      case Registry.lookup(ClientMock, "/stream-bytes/" <> length) do
         [{_, current}] when current < max ->
           Registry.update_value(
-            Pleroma.ReverseProxy.ClientMock,
+            ClientMock,
             "/stream-bytes/" <> length,
             &(&1 + 10)
           )
@@ -100,7 +103,7 @@ defmodule Pleroma.ReverseProxyTest do
           {:ok, "0123456789", client}
 
         [{_, ^max}] ->
-          Registry.unregister(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length)
+          Registry.unregister(ClientMock, "/stream-bytes/" <> length)
           :done
       end
     end)
@@ -214,24 +217,24 @@ defmodule Pleroma.ReverseProxyTest do
     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"]
+    assert 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)
+      Registry.register(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
+      case Registry.lookup(ClientMock, url) do
         [{_, 0}] ->
-          Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
+          Registry.update_value(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)
+          Registry.unregister(ClientMock, url)
           :done
       end
     end)
@@ -244,7 +247,7 @@ defmodule Pleroma.ReverseProxyTest do
 
     test "header passes", %{conn: conn} do
       conn =
-        Plug.Conn.put_req_header(
+        Conn.put_req_header(
           conn,
           "accept",
           "text/html"
@@ -257,7 +260,7 @@ defmodule Pleroma.ReverseProxyTest do
 
     test "header is filtered", %{conn: conn} do
       conn =
-        Plug.Conn.put_req_header(
+        Conn.put_req_header(
           conn,
           "accept-language",
           "en-US"
@@ -301,18 +304,18 @@ defmodule Pleroma.ReverseProxyTest do
   defp disposition_headers_mock(headers) do
     ClientMock
     |> expect(:request, fn :get, "/disposition", _, _, _ ->
-      Registry.register(Pleroma.ReverseProxy.ClientMock, "/disposition", 0)
+      Registry.register(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
+      case Registry.lookup(ClientMock, "/disposition") do
         [{_, 0}] ->
-          Registry.update_value(Pleroma.ReverseProxy.ClientMock, "/disposition", &(&1 + 1))
+          Registry.update_value(ClientMock, "/disposition", &(&1 + 1))
           {:ok, "", client}
 
         [{_, 1}] ->
-          Registry.unregister(Pleroma.ReverseProxy.ClientMock, "/disposition")
+          Registry.unregister(ClientMock, "/disposition")
           :done
       end
     end)
-- 
cgit v1.2.3