From: rinpatch <rinpatch@sdf.org>
Date: Thu, 28 May 2020 11:06:18 +0000 (+0300)
Subject: Remove tests for old pool
X-Git-Url: https://git.squeep.com/?a=commitdiff_plain;h=721e89e88bafbf0db15b590604e886e37f3291c7;p=akkoma

Remove tests for old pool
---

diff --git a/test/http/adapter_helper/gun_test.exs b/test/http/adapter_helper/gun_test.exs
index 2e961826e..49eebf355 100644
--- a/test/http/adapter_helper/gun_test.exs
+++ b/test/http/adapter_helper/gun_test.exs
@@ -9,24 +9,10 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest do
   import Mox
 
   alias Pleroma.Config
-  alias Pleroma.Gun.Conn
   alias Pleroma.HTTP.AdapterHelper.Gun
-  alias Pleroma.Pool.Connections
 
   setup :verify_on_exit!
 
-  defp gun_mock(_) do
-    gun_mock()
-    :ok
-  end
-
-  defp gun_mock do
-    Pleroma.GunMock
-    |> stub(:open, fn _, _, _ -> Task.start_link(fn -> Process.sleep(1000) end) end)
-    |> stub(:await_up, fn _, _ -> {:ok, :http} end)
-    |> stub(:set_owner, fn _, _ -> :ok end)
-  end
-
   describe "options/1" do
     setup do: clear_config([:http, :adapter], a: 1, b: 2)
 
@@ -62,46 +48,12 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest do
       assert opts[:certificates_verification]
     end
 
-    test "get conn on next request" do
-      gun_mock()
-      level = Application.get_env(:logger, :level)
-      Logger.configure(level: :debug)
-      on_exit(fn -> Logger.configure(level: level) end)
-      uri = URI.parse("http://some-domain2.com")
-
-      opts = Gun.options(uri)
-
-      assert opts[:conn] == nil
-      assert opts[:close_conn] == nil
-
-      Process.sleep(50)
-      opts = Gun.options(uri)
-
-      assert is_pid(opts[:conn])
-      assert opts[:close_conn] == false
-    end
-
     test "merges with defaul http adapter config" do
       defaults = Gun.options([receive_conn: false], URI.parse("https://example.com"))
       assert Keyword.has_key?(defaults, :a)
       assert Keyword.has_key?(defaults, :b)
     end
 
-    test "default ssl adapter opts with connection" do
-      gun_mock()
-      uri = URI.parse("https://some-domain.com")
-
-      :ok = Conn.open(uri, :gun_connections)
-
-      opts = Gun.options(uri)
-
-      assert opts[:certificates_verification]
-      refute opts[:tls_opts] == []
-
-      assert opts[:close_conn] == false
-      assert is_pid(opts[:conn])
-    end
-
     test "parses string proxy host & port" do
       proxy = Config.get([:http, :proxy_url])
       Config.put([:http, :proxy_url], "localhost:8123")
@@ -132,127 +84,4 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest do
       assert opts[:proxy] == {'example.com', 4321}
     end
   end
-
-  describe "options/1 with receive_conn parameter" do
-    setup :gun_mock
-
-    test "receive conn by default" do
-      uri = URI.parse("http://another-domain.com")
-      :ok = Conn.open(uri, :gun_connections)
-
-      received_opts = Gun.options(uri)
-      assert received_opts[:close_conn] == false
-      assert is_pid(received_opts[:conn])
-    end
-
-    test "don't receive conn if receive_conn is false" do
-      uri = URI.parse("http://another-domain.com")
-      :ok = Conn.open(uri, :gun_connections)
-
-      opts = [receive_conn: false]
-      received_opts = Gun.options(opts, uri)
-      assert received_opts[:close_conn] == nil
-      assert received_opts[:conn] == nil
-    end
-  end
-
-  describe "after_request/1" do
-    setup :gun_mock
-
-    test "body_as not chunks" do
-      uri = URI.parse("http://some-domain.com")
-      :ok = Conn.open(uri, :gun_connections)
-      opts = Gun.options(uri)
-      :ok = Gun.after_request(opts)
-      conn = opts[:conn]
-
-      assert %Connections{
-               conns: %{
-                 "http:some-domain.com:80" => %Pleroma.Gun.Conn{
-                   conn: ^conn,
-                   conn_state: :idle,
-                   used_by: []
-                 }
-               }
-             } = Connections.get_state(:gun_connections)
-    end
-
-    test "body_as chunks" do
-      uri = URI.parse("http://some-domain.com")
-      :ok = Conn.open(uri, :gun_connections)
-      opts = Gun.options([body_as: :chunks], uri)
-      :ok = Gun.after_request(opts)
-      conn = opts[:conn]
-      self = self()
-
-      assert %Connections{
-               conns: %{
-                 "http:some-domain.com:80" => %Pleroma.Gun.Conn{
-                   conn: ^conn,
-                   conn_state: :active,
-                   used_by: [{^self, _}]
-                 }
-               }
-             } = Connections.get_state(:gun_connections)
-    end
-
-    test "with no connection" do
-      uri = URI.parse("http://uniq-domain.com")
-
-      :ok = Conn.open(uri, :gun_connections)
-
-      opts = Gun.options([body_as: :chunks], uri)
-      conn = opts[:conn]
-      opts = Keyword.delete(opts, :conn)
-      self = self()
-
-      :ok = Gun.after_request(opts)
-
-      assert %Connections{
-               conns: %{
-                 "http:uniq-domain.com:80" => %Pleroma.Gun.Conn{
-                   conn: ^conn,
-                   conn_state: :active,
-                   used_by: [{^self, _}]
-                 }
-               }
-             } = Connections.get_state(:gun_connections)
-    end
-
-    test "with ipv4" do
-      uri = URI.parse("http://127.0.0.1")
-      :ok = Conn.open(uri, :gun_connections)
-      opts = Gun.options(uri)
-      :ok = Gun.after_request(opts)
-      conn = opts[:conn]
-
-      assert %Connections{
-               conns: %{
-                 "http:127.0.0.1:80" => %Pleroma.Gun.Conn{
-                   conn: ^conn,
-                   conn_state: :idle,
-                   used_by: []
-                 }
-               }
-             } = Connections.get_state(:gun_connections)
-    end
-
-    test "with ipv6" do
-      uri = URI.parse("http://[2a03:2880:f10c:83:face:b00c:0:25de]")
-      :ok = Conn.open(uri, :gun_connections)
-      opts = Gun.options(uri)
-      :ok = Gun.after_request(opts)
-      conn = opts[:conn]
-
-      assert %Connections{
-               conns: %{
-                 "http:2a03:2880:f10c:83:face:b00c:0:25de:80" => %Pleroma.Gun.Conn{
-                   conn: ^conn,
-                   conn_state: :idle,
-                   used_by: []
-                 }
-               }
-             } = Connections.get_state(:gun_connections)
-    end
-  end
 end
diff --git a/test/http/connection_test.exs b/test/http/connection_test.exs
deleted file mode 100644
index 7c94a50b2..000000000
--- a/test/http/connection_test.exs
+++ /dev/null
@@ -1,135 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.HTTP.ConnectionTest do
-  use ExUnit.Case
-  use Pleroma.Tests.Helpers
-
-  import ExUnit.CaptureLog
-
-  alias Pleroma.Config
-  alias Pleroma.HTTP.Connection
-
-  describe "parse_host/1" do
-    test "as atom to charlist" do
-      assert Connection.parse_host(:localhost) == 'localhost'
-    end
-
-    test "as string to charlist" do
-      assert Connection.parse_host("localhost.com") == 'localhost.com'
-    end
-
-    test "as string ip to tuple" do
-      assert Connection.parse_host("127.0.0.1") == {127, 0, 0, 1}
-    end
-  end
-
-  describe "parse_proxy/1" do
-    test "ip with port" do
-      assert Connection.parse_proxy("127.0.0.1:8123") == {:ok, {127, 0, 0, 1}, 8123}
-    end
-
-    test "host with port" do
-      assert Connection.parse_proxy("localhost:8123") == {:ok, 'localhost', 8123}
-    end
-
-    test "as tuple" do
-      assert Connection.parse_proxy({:socks4, :localhost, 9050}) ==
-               {:ok, :socks4, 'localhost', 9050}
-    end
-
-    test "as tuple with string host" do
-      assert Connection.parse_proxy({:socks5, "localhost", 9050}) ==
-               {:ok, :socks5, 'localhost', 9050}
-    end
-  end
-
-  describe "parse_proxy/1 errors" do
-    test "ip without port" do
-      capture_log(fn ->
-        assert Connection.parse_proxy("127.0.0.1") == {:error, :invalid_proxy}
-      end) =~ "parsing proxy fail \"127.0.0.1\""
-    end
-
-    test "host without port" do
-      capture_log(fn ->
-        assert Connection.parse_proxy("localhost") == {:error, :invalid_proxy}
-      end) =~ "parsing proxy fail \"localhost\""
-    end
-
-    test "host with bad port" do
-      capture_log(fn ->
-        assert Connection.parse_proxy("localhost:port") == {:error, :invalid_proxy_port}
-      end) =~ "parsing port in proxy fail \"localhost:port\""
-    end
-
-    test "ip with bad port" do
-      capture_log(fn ->
-        assert Connection.parse_proxy("127.0.0.1:15.9") == {:error, :invalid_proxy_port}
-      end) =~ "parsing port in proxy fail \"127.0.0.1:15.9\""
-    end
-
-    test "as tuple without port" do
-      capture_log(fn ->
-        assert Connection.parse_proxy({:socks5, :localhost}) == {:error, :invalid_proxy}
-      end) =~ "parsing proxy fail {:socks5, :localhost}"
-    end
-
-    test "with nil" do
-      assert Connection.parse_proxy(nil) == nil
-    end
-  end
-
-  describe "options/3" do
-    setup do: clear_config([:http, :proxy_url])
-
-    test "without proxy_url in config" do
-      Config.delete([:http, :proxy_url])
-
-      opts = Connection.options(%URI{})
-      refute Keyword.has_key?(opts, :proxy)
-    end
-
-    test "parses string proxy host & port" do
-      Config.put([:http, :proxy_url], "localhost:8123")
-
-      opts = Connection.options(%URI{})
-      assert opts[:proxy] == {'localhost', 8123}
-    end
-
-    test "parses tuple proxy scheme host and port" do
-      Config.put([:http, :proxy_url], {:socks, 'localhost', 1234})
-
-      opts = Connection.options(%URI{})
-      assert opts[:proxy] == {:socks, 'localhost', 1234}
-    end
-
-    test "passed opts have more weight than defaults" do
-      Config.put([:http, :proxy_url], {:socks5, 'localhost', 1234})
-
-      opts = Connection.options(%URI{}, proxy: {'example.com', 4321})
-
-      assert opts[:proxy] == {'example.com', 4321}
-    end
-  end
-
-  describe "format_host/1" do
-    test "with domain" do
-      assert Connection.format_host("example.com") == 'example.com'
-    end
-
-    test "with idna domain" do
-      assert Connection.format_host("ですexample.com") == 'xn--example-183fne.com'
-    end
-
-    test "with ipv4" do
-      assert Connection.format_host("127.0.0.1") == '127.0.0.1'
-    end
-
-    test "with ipv6" do
-      assert Connection.format_host("2a03:2880:f10c:83:face:b00c:0:25de") ==
-               '2a03:2880:f10c:83:face:b00c:0:25de'
-    end
-  end
-end
diff --git a/test/pool/connections_test.exs b/test/pool/connections_test.exs
deleted file mode 100644
index aeda54875..000000000
--- a/test/pool/connections_test.exs
+++ /dev/null
@@ -1,760 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Pool.ConnectionsTest do
-  use ExUnit.Case, async: true
-  use Pleroma.Tests.Helpers
-
-  import ExUnit.CaptureLog
-  import Mox
-
-  alias Pleroma.Gun.Conn
-  alias Pleroma.GunMock
-  alias Pleroma.Pool.Connections
-
-  setup :verify_on_exit!
-
-  setup_all do
-    name = :test_connections
-    {:ok, pid} = Connections.start_link({name, [checkin_timeout: 150]})
-    {:ok, _} = Registry.start_link(keys: :unique, name: Pleroma.GunMock)
-
-    on_exit(fn ->
-      if Process.alive?(pid), do: GenServer.stop(name)
-    end)
-
-    {:ok, name: name}
-  end
-
-  defp open_mock(num \\ 1) do
-    GunMock
-    |> expect(:open, num, &start_and_register(&1, &2, &3))
-    |> expect(:await_up, num, fn _, _ -> {:ok, :http} end)
-    |> expect(:set_owner, num, fn _, _ -> :ok end)
-  end
-
-  defp connect_mock(mock) do
-    mock
-    |> expect(:connect, &connect(&1, &2))
-    |> expect(:await, &await(&1, &2))
-  end
-
-  defp info_mock(mock), do: expect(mock, :info, &info(&1))
-
-  defp start_and_register('gun-not-up.com', _, _), do: {:error, :timeout}
-
-  defp start_and_register(host, port, _) do
-    {:ok, pid} = Task.start_link(fn -> Process.sleep(1000) end)
-
-    scheme =
-      case port do
-        443 -> "https"
-        _ -> "http"
-      end
-
-    Registry.register(GunMock, pid, %{
-      origin_scheme: scheme,
-      origin_host: host,
-      origin_port: port
-    })
-
-    {:ok, pid}
-  end
-
-  defp info(pid) do
-    [{_, info}] = Registry.lookup(GunMock, pid)
-    info
-  end
-
-  defp connect(pid, _) do
-    ref = make_ref()
-    Registry.register(GunMock, ref, pid)
-    ref
-  end
-
-  defp await(pid, ref) do
-    [{_, ^pid}] = Registry.lookup(GunMock, ref)
-    {:response, :fin, 200, []}
-  end
-
-  defp now, do: :os.system_time(:second)
-
-  describe "alive?/2" do
-    test "is alive", %{name: name} do
-      assert Connections.alive?(name)
-    end
-
-    test "returns false if not started" do
-      refute Connections.alive?(:some_random_name)
-    end
-  end
-
-  test "opens connection and reuse it on next request", %{name: name} do
-    open_mock()
-    url = "http://some-domain.com"
-    key = "http:some-domain.com:80"
-    refute Connections.checkin(url, name)
-    :ok = Conn.open(url, name)
-
-    conn = Connections.checkin(url, name)
-    assert is_pid(conn)
-    assert Process.alive?(conn)
-
-    self = self()
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-
-    reused_conn = Connections.checkin(url, name)
-
-    assert conn == reused_conn
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}, {^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-
-    :ok = Connections.checkout(conn, self, name)
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-
-    :ok = Connections.checkout(conn, self, name)
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [],
-          conn_state: :idle
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  test "reuse connection for idna domains", %{name: name} do
-    open_mock()
-    url = "http://ですsome-domain.com"
-    refute Connections.checkin(url, name)
-
-    :ok = Conn.open(url, name)
-
-    conn = Connections.checkin(url, name)
-    assert is_pid(conn)
-    assert Process.alive?(conn)
-
-    self = self()
-
-    %Connections{
-      conns: %{
-        "http:ですsome-domain.com:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-
-    reused_conn = Connections.checkin(url, name)
-
-    assert conn == reused_conn
-  end
-
-  test "reuse for ipv4", %{name: name} do
-    open_mock()
-    url = "http://127.0.0.1"
-
-    refute Connections.checkin(url, name)
-
-    :ok = Conn.open(url, name)
-
-    conn = Connections.checkin(url, name)
-    assert is_pid(conn)
-    assert Process.alive?(conn)
-
-    self = self()
-
-    %Connections{
-      conns: %{
-        "http:127.0.0.1:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-
-    reused_conn = Connections.checkin(url, name)
-
-    assert conn == reused_conn
-
-    :ok = Connections.checkout(conn, self, name)
-    :ok = Connections.checkout(reused_conn, self, name)
-
-    %Connections{
-      conns: %{
-        "http:127.0.0.1:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [],
-          conn_state: :idle
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  test "reuse for ipv6", %{name: name} do
-    open_mock()
-    url = "http://[2a03:2880:f10c:83:face:b00c:0:25de]"
-
-    refute Connections.checkin(url, name)
-
-    :ok = Conn.open(url, name)
-
-    conn = Connections.checkin(url, name)
-    assert is_pid(conn)
-    assert Process.alive?(conn)
-
-    self = self()
-
-    %Connections{
-      conns: %{
-        "http:2a03:2880:f10c:83:face:b00c:0:25de:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-
-    reused_conn = Connections.checkin(url, name)
-
-    assert conn == reused_conn
-  end
-
-  test "up and down ipv4", %{name: name} do
-    open_mock()
-    |> info_mock()
-    |> allow(self(), name)
-
-    self = self()
-    url = "http://127.0.0.1"
-    :ok = Conn.open(url, name)
-    conn = Connections.checkin(url, name)
-    send(name, {:gun_down, conn, nil, nil, nil})
-    send(name, {:gun_up, conn, nil})
-
-    %Connections{
-      conns: %{
-        "http:127.0.0.1:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  test "up and down ipv6", %{name: name} do
-    self = self()
-
-    open_mock()
-    |> info_mock()
-    |> allow(self, name)
-
-    url = "http://[2a03:2880:f10c:83:face:b00c:0:25de]"
-    :ok = Conn.open(url, name)
-    conn = Connections.checkin(url, name)
-    send(name, {:gun_down, conn, nil, nil, nil})
-    send(name, {:gun_up, conn, nil})
-
-    %Connections{
-      conns: %{
-        "http:2a03:2880:f10c:83:face:b00c:0:25de:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}],
-          conn_state: :active
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  test "reuses connection based on protocol", %{name: name} do
-    open_mock(2)
-    http_url = "http://some-domain.com"
-    http_key = "http:some-domain.com:80"
-    https_url = "https://some-domain.com"
-    https_key = "https:some-domain.com:443"
-
-    refute Connections.checkin(http_url, name)
-    :ok = Conn.open(http_url, name)
-    conn = Connections.checkin(http_url, name)
-    assert is_pid(conn)
-    assert Process.alive?(conn)
-
-    refute Connections.checkin(https_url, name)
-    :ok = Conn.open(https_url, name)
-    https_conn = Connections.checkin(https_url, name)
-
-    refute conn == https_conn
-
-    reused_https = Connections.checkin(https_url, name)
-
-    refute conn == reused_https
-
-    assert reused_https == https_conn
-
-    %Connections{
-      conns: %{
-        ^http_key => %Conn{
-          conn: ^conn,
-          gun_state: :up
-        },
-        ^https_key => %Conn{
-          conn: ^https_conn,
-          gun_state: :up
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  test "connection can't get up", %{name: name} do
-    expect(GunMock, :open, &start_and_register(&1, &2, &3))
-    url = "http://gun-not-up.com"
-
-    assert capture_log(fn ->
-             refute Conn.open(url, name)
-             refute Connections.checkin(url, name)
-           end) =~
-             "Opening connection to http://gun-not-up.com failed with error {:error, :timeout}"
-  end
-
-  test "process gun_down message and then gun_up", %{name: name} do
-    self = self()
-
-    open_mock()
-    |> info_mock()
-    |> allow(self, name)
-
-    url = "http://gun-down-and-up.com"
-    key = "http:gun-down-and-up.com:80"
-    :ok = Conn.open(url, name)
-    conn = Connections.checkin(url, name)
-
-    assert is_pid(conn)
-    assert Process.alive?(conn)
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: ^conn,
-          gun_state: :up,
-          used_by: [{^self, _}]
-        }
-      }
-    } = Connections.get_state(name)
-
-    send(name, {:gun_down, conn, :http, nil, nil})
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: ^conn,
-          gun_state: :down,
-          used_by: [{^self, _}]
-        }
-      }
-    } = Connections.get_state(name)
-
-    send(name, {:gun_up, conn, :http})
-
-    conn2 = Connections.checkin(url, name)
-    assert conn == conn2
-
-    assert is_pid(conn2)
-    assert Process.alive?(conn2)
-
-    %Connections{
-      conns: %{
-        ^key => %Conn{
-          conn: _,
-          gun_state: :up,
-          used_by: [{^self, _}, {^self, _}]
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  test "async processes get same conn for same domain", %{name: name} do
-    open_mock()
-    url = "http://some-domain.com"
-    :ok = Conn.open(url, name)
-
-    tasks =
-      for _ <- 1..5 do
-        Task.async(fn ->
-          Connections.checkin(url, name)
-        end)
-      end
-
-    tasks_with_results = Task.yield_many(tasks)
-
-    results =
-      Enum.map(tasks_with_results, fn {task, res} ->
-        res || Task.shutdown(task, :brutal_kill)
-      end)
-
-    conns = for {:ok, value} <- results, do: value
-
-    %Connections{
-      conns: %{
-        "http:some-domain.com:80" => %Conn{
-          conn: conn,
-          gun_state: :up
-        }
-      }
-    } = Connections.get_state(name)
-
-    assert Enum.all?(conns, fn res -> res == conn end)
-  end
-
-  test "remove frequently used and idle", %{name: name} do
-    open_mock(3)
-    self = self()
-    http_url = "http://some-domain.com"
-    https_url = "https://some-domain.com"
-    :ok = Conn.open(https_url, name)
-    :ok = Conn.open(http_url, name)
-
-    conn1 = Connections.checkin(https_url, name)
-
-    [conn2 | _conns] =
-      for _ <- 1..4 do
-        Connections.checkin(http_url, name)
-      end
-
-    http_key = "http:some-domain.com:80"
-
-    %Connections{
-      conns: %{
-        ^http_key => %Conn{
-          conn: ^conn2,
-          gun_state: :up,
-          conn_state: :active,
-          used_by: [{^self, _}, {^self, _}, {^self, _}, {^self, _}]
-        },
-        "https:some-domain.com:443" => %Conn{
-          conn: ^conn1,
-          gun_state: :up,
-          conn_state: :active,
-          used_by: [{^self, _}]
-        }
-      }
-    } = Connections.get_state(name)
-
-    :ok = Connections.checkout(conn1, self, name)
-
-    another_url = "http://another-domain.com"
-    :ok = Conn.open(another_url, name)
-    conn = Connections.checkin(another_url, name)
-
-    %Connections{
-      conns: %{
-        "http:another-domain.com:80" => %Conn{
-          conn: ^conn,
-          gun_state: :up
-        },
-        ^http_key => %Conn{
-          conn: _,
-          gun_state: :up
-        }
-      }
-    } = Connections.get_state(name)
-  end
-
-  describe "with proxy" do
-    test "as ip", %{name: name} do
-      open_mock()
-      |> connect_mock()
-
-      url = "http://proxy-string.com"
-      key = "http:proxy-string.com:80"
-      :ok = Conn.open(url, name, proxy: {{127, 0, 0, 1}, 8123})
-
-      conn = Connections.checkin(url, name)
-
-      %Connections{
-        conns: %{
-          ^key => %Conn{
-            conn: ^conn,
-            gun_state: :up
-          }
-        }
-      } = Connections.get_state(name)
-
-      reused_conn = Connections.checkin(url, name)
-
-      assert reused_conn == conn
-    end
-
-    test "as host", %{name: name} do
-      open_mock()
-      |> connect_mock()
-
-      url = "http://proxy-tuple-atom.com"
-      :ok = Conn.open(url, name, proxy: {'localhost', 9050})
-      conn = Connections.checkin(url, name)
-
-      %Connections{
-        conns: %{
-          "http:proxy-tuple-atom.com:80" => %Conn{
-            conn: ^conn,
-            gun_state: :up
-          }
-        }
-      } = Connections.get_state(name)
-
-      reused_conn = Connections.checkin(url, name)
-
-      assert reused_conn == conn
-    end
-
-    test "as ip and ssl", %{name: name} do
-      open_mock()
-      |> connect_mock()
-
-      url = "https://proxy-string.com"
-
-      :ok = Conn.open(url, name, proxy: {{127, 0, 0, 1}, 8123})
-      conn = Connections.checkin(url, name)
-
-      %Connections{
-        conns: %{
-          "https:proxy-string.com:443" => %Conn{
-            conn: ^conn,
-            gun_state: :up
-          }
-        }
-      } = Connections.get_state(name)
-
-      reused_conn = Connections.checkin(url, name)
-
-      assert reused_conn == conn
-    end
-
-    test "as host and ssl", %{name: name} do
-      open_mock()
-      |> connect_mock()
-
-      url = "https://proxy-tuple-atom.com"
-      :ok = Conn.open(url, name, proxy: {'localhost', 9050})
-      conn = Connections.checkin(url, name)
-
-      %Connections{
-        conns: %{
-          "https:proxy-tuple-atom.com:443" => %Conn{
-            conn: ^conn,
-            gun_state: :up
-          }
-        }
-      } = Connections.get_state(name)
-
-      reused_conn = Connections.checkin(url, name)
-
-      assert reused_conn == conn
-    end
-
-    test "with socks type", %{name: name} do
-      open_mock()
-
-      url = "http://proxy-socks.com"
-
-      :ok = Conn.open(url, name, proxy: {:socks5, 'localhost', 1234})
-
-      conn = Connections.checkin(url, name)
-
-      %Connections{
-        conns: %{
-          "http:proxy-socks.com:80" => %Conn{
-            conn: ^conn,
-            gun_state: :up
-          }
-        }
-      } = Connections.get_state(name)
-
-      reused_conn = Connections.checkin(url, name)
-
-      assert reused_conn == conn
-    end
-
-    test "with socks4 type and ssl", %{name: name} do
-      open_mock()
-      url = "https://proxy-socks.com"
-
-      :ok = Conn.open(url, name, proxy: {:socks4, 'localhost', 1234})
-
-      conn = Connections.checkin(url, name)
-
-      %Connections{
-        conns: %{
-          "https:proxy-socks.com:443" => %Conn{
-            conn: ^conn,
-            gun_state: :up
-          }
-        }
-      } = Connections.get_state(name)
-
-      reused_conn = Connections.checkin(url, name)
-
-      assert reused_conn == conn
-    end
-  end
-
-  describe "crf/3" do
-    setup do
-      crf = Connections.crf(1, 10, 1)
-      {:ok, crf: crf}
-    end
-
-    test "more used will have crf higher", %{crf: crf} do
-      # used 3 times
-      crf1 = Connections.crf(1, 10, crf)
-      crf1 = Connections.crf(1, 10, crf1)
-
-      # used 2 times
-      crf2 = Connections.crf(1, 10, crf)
-
-      assert crf1 > crf2
-    end
-
-    test "recently used will have crf higher on equal references", %{crf: crf} do
-      # used 3 sec ago
-      crf1 = Connections.crf(3, 10, crf)
-
-      # used 4 sec ago
-      crf2 = Connections.crf(4, 10, crf)
-
-      assert crf1 > crf2
-    end
-
-    test "equal crf on equal reference and time", %{crf: crf} do
-      # used 2 times
-      crf1 = Connections.crf(1, 10, crf)
-
-      # used 2 times
-      crf2 = Connections.crf(1, 10, crf)
-
-      assert crf1 == crf2
-    end
-
-    test "recently used will have higher crf", %{crf: crf} do
-      crf1 = Connections.crf(2, 10, crf)
-      crf1 = Connections.crf(1, 10, crf1)
-
-      crf2 = Connections.crf(3, 10, crf)
-      crf2 = Connections.crf(4, 10, crf2)
-      assert crf1 > crf2
-    end
-  end
-
-  describe "get_unused_conns/1" do
-    test "crf is equalent, sorting by reference", %{name: name} do
-      Connections.add_conn(name, "1", %Conn{
-        conn_state: :idle,
-        last_reference: now() - 1
-      })
-
-      Connections.add_conn(name, "2", %Conn{
-        conn_state: :idle,
-        last_reference: now()
-      })
-
-      assert [{"1", _unused_conn} | _others] = Connections.get_unused_conns(name)
-    end
-
-    test "reference is equalent, sorting by crf", %{name: name} do
-      Connections.add_conn(name, "1", %Conn{
-        conn_state: :idle,
-        crf: 1.999
-      })
-
-      Connections.add_conn(name, "2", %Conn{
-        conn_state: :idle,
-        crf: 2
-      })
-
-      assert [{"1", _unused_conn} | _others] = Connections.get_unused_conns(name)
-    end
-
-    test "higher crf and lower reference", %{name: name} do
-      Connections.add_conn(name, "1", %Conn{
-        conn_state: :idle,
-        crf: 3,
-        last_reference: now() - 1
-      })
-
-      Connections.add_conn(name, "2", %Conn{
-        conn_state: :idle,
-        crf: 2,
-        last_reference: now()
-      })
-
-      assert [{"2", _unused_conn} | _others] = Connections.get_unused_conns(name)
-    end
-
-    test "lower crf and lower reference", %{name: name} do
-      Connections.add_conn(name, "1", %Conn{
-        conn_state: :idle,
-        crf: 1.99,
-        last_reference: now() - 1
-      })
-
-      Connections.add_conn(name, "2", %Conn{
-        conn_state: :idle,
-        crf: 2,
-        last_reference: now()
-      })
-
-      assert [{"1", _unused_conn} | _others] = Connections.get_unused_conns(name)
-    end
-  end
-
-  test "count/1" do
-    name = :test_count
-    {:ok, _} = Connections.start_link({name, [checkin_timeout: 150]})
-    assert Connections.count(name) == 0
-    Connections.add_conn(name, "1", %Conn{conn: self()})
-    assert Connections.count(name) == 1
-    Connections.remove_conn(name, "1")
-    assert Connections.count(name) == 0
-  end
-end