Print loaded params for unexpected route failure

Author: danschultzer

README.md

@@ -106,7 +106,7 @@ end)
 TestServer.plug(fn conn ->
   {:ok, body, _conn} = Plug.Conn.read_body(conn, [])
 
-  Map.put(conn, :request_body, body)
+  %{conn | body_params: Jason.decode!(body)}
 end)
 
 TestServer.plug(MyPlug)

lib/test_server.ex

@@ -186,8 +186,11 @@ defmodule TestServer do
 
         message =
           case function_accepts_instance_arg do
-            true -> "Multiple #{inspect(Instance)}'s running, please pass instance to `#{inspect(m)}.#{f}/#{a}`."
-            false -> "Multiple #{inspect(Instance)}'s running."
+            true ->
+              "Multiple #{inspect(Instance)}'s running, please pass instance to `#{inspect(m)}.#{f}/#{a}`."
+
+            false ->
+              "Multiple #{inspect(Instance)}'s running."
           end
 
         raise """

lib/test_server/instance.ex

@@ -33,7 +33,9 @@ defmodule TestServer.Instance do
   end
 
   @spec dispatch(pid(), Plug.Conn.t()) ::
-          {:ok, Plug.Conn.t()} | {:error, :not_found} | {:error, {term(), list()}}
+          {:ok, Plug.Conn.t()}
+          | {:error, {:not_found, Plug.Conn.t()}}
+          | {:error, {term(), list()}}
   def dispatch(instance, conn) do
     GenServer.call(instance, {:dispatch, conn})
   end
@@ -51,8 +53,6 @@ defmodule TestServer.Instance do
   end
 
   @spec format_routes([map()]) :: binary()
-  def format_routes([]), do: "None"
-
   def format_routes(routes) do
     routes
     |> Enum.with_index()
@@ -229,7 +229,7 @@ defmodule TestServer.Instance do
     |> Enum.find_index(&matches?(&1, conn))
     |> case do
       nil ->
-        {{:error, :not_found}, state}
+        {{:error, {:not_found, conn}}, state}
 
       index ->
         %{to: plug, stacktrace: stacktrace} = Enum.at(state.routes, index)

lib/test_server/plug_cowboy.ex

@@ -112,24 +112,41 @@ defmodule TestServer.Plug.Cowboy do
         {:ok, conn} ->
           conn
 
-        {:error, :not_found} ->
-          resp_error(
-            conn,
-            instance,
-            {RuntimeError.exception("""
-             Unexpected #{conn.method} request received at #{conn.request_path}.
+        {:error, {:not_found, conn}} ->
+          message =
+            "Unexpected #{conn.method} request received at #{conn.request_path}"
+            |> append_params(conn)
+            |> format_active_routes(Instance.active_routes(instance), instance)
 
-             Active routes for request:
-
-             #{Instance.format_routes(Instance.active_routes(instance))}
-             """), []}
-          )
+          resp_error(conn, instance, {RuntimeError.exception(message), []})
 
         {:error, {error, stacktrace}} ->
           resp_error(conn, instance, {error, stacktrace})
       end
     end
 
+    defp append_params(message, conn) do
+      conn
+      |> Map.take([:query_params, :body_params])
+      |> Enum.filter(fn
+        {_key, %Conn.Unfetched{}} -> false
+        {_key, empty} when empty == %{} -> false
+        {_key, params} when is_map(params) -> true
+      end)
+      |> case do
+        [] -> message <> "."
+        params -> message <> " with params:\n\n#{inspect(Map.new(params), pretty: true)}"
+      end
+    end
+
+    defp format_active_routes(message, [], instance),
+      do: message <> "\n\nNo active routes for #{inspect(Instance)} #{inspect(instance)}"
+
+    defp format_active_routes(message, active_routes, instance) do
+      message <>
+        "\n\nActive routes for #{inspect(Instance)} #{inspect(instance)}:\n\n#{Instance.format_routes(active_routes)}"
+    end
+
     defp resp_error(conn, instance, {exception, stacktrace}) do
       Instance.report_error(instance, {exception, stacktrace})
 

test/test_server_test.exs

@@ -242,11 +242,13 @@ defmodule TestServerTest do
           assert :ok = TestServer.add("/")
 
           assert {:ok, _} = unquote(__MODULE__).request(TestServer.url("/"))
-          assert {:error, _} = unquote(__MODULE__).request(TestServer.url("/"))
+          assert {:error, _} = unquote(__MODULE__).request(TestServer.url("/?a=1"))
         end
       end
 
-      assert capture_io(fn -> ExUnit.run() end) =~ "Unexpected GET request received at /."
+      assert captured_io = capture_io(fn -> ExUnit.run() end)
+      assert captured_io =~ "Unexpected GET request received at / with params:"
+      assert captured_io =~ "query_params: %{\"a\" => \"1\"}"
     end
 
     test "with no requests" do