Merge pull request #7 from danschultzer/ipv6

Add option for IP address type

Author: danschultzer

CHANGELOG.md

@@ -1,3 +1,10 @@
+## v0.1.9 (TBA)
+
+- `:httpd` server adapter now parses remote ip to tuple format
+- `:httpd` server adapter now parses host from host header
+- Specifying `:host` now also binds the hostname to IPv6 loopback
+- Added `:ipfamily` option to set IP address type to use
+
 ## v0.1.8 (2023-02-10)
 
 - Support Bandit and httpd web server

README.md

@@ -155,6 +155,14 @@ TestServer.start(http_server: {Bandit, []})
 
 You can create your own plug based HTTP Server Adapter by using the `TestServer.HTTPServer` behaviour.
 
+### IPv6
+
+Use the `:ipfamily` option to test with IPv6 when you are starting the test server:
+
+```elixir
+TestServer.start(ipfamily: :inet6)
+```
+
 <!-- MDOC !-->
 
 ## LICENSE

lib/test_server.ex

@@ -26,6 +26,8 @@ defmodule TestServer do
     * `:port`             - integer of port number, defaults to random port that can be opened;
     * `:scheme`           - an atom for the http scheme. Defaults to `:http`;
     * `:http_server`      - HTTP server configuration. Defaults to `{TestServer.HTTPServer.Httpd, []}`;
+    * `:tls`              - Passthru options for TLS configuration handled by the webserver;
+    * `:ipfamily`         - The IP address type to use, either `:inet` or `:inet6`. Defaults to `:inet`;
   """
   @spec start(keyword()) :: {:ok, pid()}
   def start(options \\ []) do
@@ -158,7 +160,7 @@ defmodule TestServer do
   Produces a URL for current test server.
 
   ## Options
-    * `:host` - binary host value, it'll be added to inet for IP 127.0.0.1, defaults to `"localhost"`;
+    * `:host` - binary host value, it'll be added to inet for IP `127.0.0.1` and `::1`, defaults to `"localhost"`;
   """
   @spec url(binary(), keyword()) :: binary()
   def url(uri, opts) when is_binary(uri), do: url(fetch_instance!(), uri, opts)
@@ -235,6 +237,7 @@ defmodule TestServer do
   defp maybe_enable_host(host) do
     :inet_db.set_lookup([:file, :dns])
     :inet_db.add_host({127, 0, 0, 1}, [String.to_charlist(host)])
+    :inet_db.add_host({0, 0, 0, 0, 0, 0, 0, 1}, [String.to_charlist(host)])
 
     host
   end

lib/test_server/http_server.ex

@@ -24,10 +24,10 @@ defmodule TestServer.HTTPServer do
   @type scheme :: :http | :https
   @type instance :: pid()
   @type port_number :: :inet.port_number()
-  @type tls_options :: keyword()
+  @type options :: [tls: keyword(), ipfamily: :inet | :inet6]
   @type server_options :: keyword()
 
-  @callback start(instance(), port_number(), scheme(), tls_options(), server_options()) :: {:ok, pid(), server_options()} | {:error, any()}
+  @callback start(instance(), port_number(), scheme(), options(), server_options()) :: {:ok, pid(), server_options()} | {:error, any()}
   @callback stop(instance(), server_options()) :: :ok | {:error, any()}
   @callback get_socket_pid(Plug.Conn.t()) :: pid()
 
@@ -46,9 +46,11 @@ defmodule TestServer.HTTPServer do
     port = open_port(options)
     scheme = parse_scheme(options)
     {tls_options, x509_options} = maybe_generate_x509_suite(options, scheme)
+    ip_family = Keyword.get(options, :ipfamily, :inet)
+    test_server_options = [tls: tls_options, ipfamily: ip_family]
     {mod, server_options} = Keyword.get(options, :http_server, Application.get_env(:test_server, :http_server, @default_http_server))
 
-    case mod.start(instance, port, scheme, tls_options, server_options) do
+    case mod.start(instance, port, scheme, test_server_options, server_options) do
       {:ok, reference, server_options} ->
         options =
           options

lib/test_server/http_server/bandit.ex

@@ -8,12 +8,14 @@ defmodule TestServer.HTTPServer.Bandit do
   @behaviour WebSock
 
   @impl TestServer.HTTPServer
-  def start(instance, port, scheme, tls_options, bandit_options) do
+  def start(instance, port, scheme, options, bandit_options) do
+    opts = [options[:ipfamily]] ++ options[:tls]
+
     thousand_islands_options =
       bandit_options
       |> Keyword.get(:options, [])
       |> Keyword.put(:port, port)
-      |> Keyword.put(:transport_options, tls_options)
+      |> Keyword.update(:transport_options, opts, & &1 ++ opts)
 
     bandit_options =
       bandit_options

lib/test_server/http_server/httpd.ex

@@ -5,7 +5,7 @@ defmodule TestServer.HTTPServer.Httpd do
   @behaviour TestServer.HTTPServer
 
   @impl TestServer.HTTPServer
-  def start(instance, port, scheme, tls_options, httpd_options) do
+  def start(instance, port, scheme, options, httpd_options) do
     httpd_options =
       httpd_options
       |> Keyword.put(:port, port)
@@ -14,7 +14,8 @@ defmodule TestServer.HTTPServer.Httpd do
       |> Keyword.put_new(:document_root, '/tmp')
       |> Keyword.put_new(:server_root, '/tmp')
       |> Keyword.put_new(:handler_plug, {TestServer.Plug, {__MODULE__, [], instance}})
-      |> put_tls_options(scheme, tls_options)
+      |> Keyword.put_new(:ipfamily, options[:ipfamily])
+      |> put_tls_options(scheme, options[:tls])
 
     case :inets.start(:httpd, httpd_options) do
       {:ok, pid} -> {:ok, pid, httpd_options}
@@ -74,6 +75,7 @@ defmodule TestServer.HTTPServer.Httpd do
     {path, qs} = request_path(data)
     {port, host} = host(data)
     {_port, remote_ip} = peer(data)
+    {:ok, remote_ip} = :inet.parse_address(remote_ip)
 
     headers = Enum.map(parsed_header(data), &{to_string(elem(&1, 0)), to_string(elem(&1, 1))})
 
@@ -84,7 +86,7 @@ defmodule TestServer.HTTPServer.Httpd do
       owner: self(),
       path_info: split_path(to_string(path)),
       port: port,
-      remote_ip: to_string(remote_ip),
+      remote_ip: remote_ip,
       query_string: qs,
       req_headers: headers,
       request_path: path,
@@ -106,9 +108,20 @@ defmodule TestServer.HTTPServer.Httpd do
   end
 
   defp host(data) do
-    {:init_data, _, host, _} = httpd(data, :init_data)
+    data
+    |> httpd(:parsed_header)
+    |> Enum.find(&elem(&1, 0) == 'host')
+    |> Kernel.||({'host', ''})
+    |> elem(1)
+    |> to_string()
+    |> :binary.split(":")
+    |> case do
+      [host, port] ->
+        {Integer.parse(port), host}
 
-    host
+      [host] ->
+        {nil, host}
+    end
   end
 
   defp peer(data) do

lib/test_server/http_server/plug_cowboy.ex

@@ -16,14 +16,15 @@ defmodule TestServer.HTTPServer.Plug.Cowboy do
   ]
 
   @impl TestServer.HTTPServer
-  def start(instance, port, scheme, tls_options, cowboy_options) do
+  def start(instance, port, scheme, options, cowboy_options) do
     cowboy_options =
       cowboy_options
       |> Keyword.put_new(:protocol_options, @default_protocol_options)
       |> Keyword.put(:port, port)
       |> Keyword.put(:dispatch, dispatch(instance))
       |> Keyword.put(:ref, cowboy_ref(port))
-      |> Keyword.merge(tls_options)
+      |> Keyword.put(:net, options[:ipfamily])
+      |> Keyword.merge(options[:tls])
 
     case apply(Cowboy, scheme, [TestServer.Plug, {__MODULE__, %{}, instance}, cowboy_options]) do
       {:ok, pid} -> {:ok, pid, cowboy_options}

test/test_server_test.exs

@@ -47,7 +47,7 @@ defmodule TestServerTest do
 
       assert %X509.Test.Suite{} = options[:x509_suite]
 
-      httpc_opts = fn cacerts ->
+      http_opts = fn cacerts ->
         [
           ssl: [
             verify: :verify_peer,
@@ -65,10 +65,27 @@ defmodule TestServerTest do
       invalid_cacerts = X509.Test.Suite.new().cacerts
 
       assert {:error, {:failed_connect, _}} =
-               request(TestServer.url("/"), httpc_opts: httpc_opts.(invalid_cacerts))
+               request(TestServer.url("/"), http_opts: http_opts.(invalid_cacerts))
 
       assert :ok = TestServer.add("/")
-      assert {:ok, _} = request(TestServer.url("/"), httpc_opts: httpc_opts.(valid_cacerts))
+      assert {:ok, _} = request(TestServer.url("/"), http_opts: http_opts.(valid_cacerts))
+    end
+
+    test "starts in IPv6-only mode`" do
+      {:ok, instance} = TestServer.start(ipfamily: :inet6)
+      options = TestServer.Instance.get_options(instance)
+
+      assert options[:ipfamily] == :inet6
+
+      assert :ok = TestServer.add("/", to: fn conn ->
+        assert conn.remote_ip == {0, 0, 0, 0, 0, 65_535, 32_512, 1}
+
+        Plug.Conn.send_resp(conn, 200, "OK")
+      end)
+
+      assert %{host: hostname} = URI.parse(TestServer.url("/"))
+      assert {:ok, {0, 0, 0, 0, 0, 0, 0, 1}} == :inet.getaddr(String.to_charlist(hostname), :inet6)
+      assert {:ok, _} = request(TestServer.url("/"))
     end
   end
 
@@ -148,7 +165,7 @@ defmodule TestServerTest do
       end
     end
 
-    test "invalid `:host`" do
+    test "with invalid `:host`" do
       TestServer.start()
 
       assert_raise RuntimeError, ~r/Invalid host, got: :invalid/, fn ->
@@ -164,6 +181,32 @@ defmodule TestServerTest do
       refute TestServer.url("/") == TestServer.url("/", host: "bad-host")
     end
 
+    test "with `:host`" do
+      TestServer.start()
+
+      assert :ok = TestServer.add("/", to: fn conn ->
+        assert conn.remote_ip == {127, 0, 0, 1}
+        assert conn.host == "custom-host"
+
+        Plug.Conn.send_resp(conn, 200, "OK")
+      end)
+
+      assert {:ok, _} = request(TestServer.url("/", host: "custom-host"))
+    end
+
+    test "with `:host` in IPv6-only mode" do
+      TestServer.start(ipfamily: :inet6, http_server: {TestServer.HTTPServer.Httpd, []})
+
+      assert :ok = TestServer.add("/", to: fn conn ->
+        assert conn.remote_ip == {0, 0, 0, 0, 0, 65_535, 32_512, 1}
+        assert conn.host == "custom-host"
+
+        Plug.Conn.send_resp(conn, 200, "OK")
+      end)
+
+      assert {:ok, _} = request(TestServer.url("/", host: "custom-host"))
+    end
+
     test "with multiple instances" do
       {:ok, instance_1} = TestServer.start()
       {:ok, instance_2} = TestServer.start()
@@ -674,13 +717,14 @@ defmodule TestServerTest do
 
   def request(url, opts \\ []) do
     url = String.to_charlist(url)
-    httpc_opts = Keyword.get(opts, :httpc_opts, [])
+    httpc_http_opts = Keyword.get(opts, :http_opts, [])
+    httpc_opts = Keyword.get(opts, :opts, [])
 
     opts
     |> Keyword.get(:method, :get)
     |> case do
-      :post -> :httpc.request(:post, {url, [], 'plain/text', 'OK'}, httpc_opts, [])
-      :get -> :httpc.request(:get, {url, []}, httpc_opts, [])
+      :post -> :httpc.request(:post, {url, [], 'plain/text', 'OK'}, httpc_http_opts, httpc_opts)
+      :get -> :httpc.request(:get, {url, []}, httpc_http_opts, httpc_opts)
     end
     |> case do
       {:ok, {{_, 200, _}, _headers, body}} -> {:ok, to_string(body)}