Refactor message formatting

Author: danschultzer

lib/test_server.ex

@@ -88,7 +88,7 @@ defmodule TestServer do
 
       active_routes ->
         raise """
-        The test ended before the following #{inspect(Instance)} #{inspect(instance)} route(s) received a request:
+        #{Instance.format_instance(instance)} did not receive a request for these routes before the test ended:
 
         #{Instance.format_routes(active_routes)}
         """
@@ -105,7 +105,7 @@ defmodule TestServer do
 
       active_websocket_handlers ->
         raise """
-        The test ended before the following #{inspect(Instance)} #{inspect(instance)} websocket handler(s) received a message:
+        #{Instance.format_instance(instance)} did not receive a frame for these websocket handlers before the test ended:
 
         #{Instance.format_websocket_handlers(active_websocket_handlers)}
         """
@@ -131,7 +131,7 @@ defmodule TestServer do
   defp instance_alive!(instance) do
     case Process.alive?(instance) do
       true -> :ok
-      false -> raise "The #{inspect(Instance)} #{inspect(instance)} is not running"
+      false -> raise "#{Instance.format_instance(instance)} is not running"
     end
   end
 
@@ -202,26 +202,26 @@ defmodule TestServer do
       [_instance | _rest] = instances ->
         [{m, f, a, _} | _stacktrace] = get_stacktrace()
 
+        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."
+          end
+
         formatted_instances =
           instances
           |> Enum.map(&{&1, Instance.get_options(&1)})
           |> Enum.with_index()
           |> Enum.map_join("\n\n", fn {{instance, options}, index} ->
             """
-            ##{index + 1}: #{inspect(instance)}
+            ##{index + 1}: #{Instance.format_instance(instance)}
                 #{Enum.map_join(options[:stacktrace], "\n    ", &Exception.format_stacktrace_entry/1)}")}
             """
           end)
 
-        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."
-          end
-
         raise """
         #{message}
 
@@ -358,10 +358,10 @@ defmodule TestServer do
 
     cond do
       not (options[:scheme] == :https) ->
-        raise "The #{inspect(Instance)} is not running with `[scheme: :https]` option"
+        raise "#{Instance.format_instance(instance)} is not running with `[scheme: :https]` option"
 
       not Keyword.has_key?(options, :x509_suite) ->
-        raise "The #{inspect(Instance)} is running with custom SSL"
+        raise "#{Instance.format_instance(instance)} is running with custom SSL"
 
       true ->
         options[:x509_suite]

lib/test_server/instance.ex

@@ -115,6 +115,11 @@ defmodule TestServer.Instance do
     end)
   end
 
+  @spec format_instance(pid()) :: binary()
+  def format_instance(instance) do
+    "#{inspect(__MODULE__)} #{inspect(instance)}"
+  end
+
   @spec websocket_handlers(pid()) :: [map()]
   def websocket_handlers(instance) do
     GenServer.call(instance, :websocket_handlers)

lib/test_server/plug_cowboy/handler.ex

@@ -31,14 +31,14 @@ defmodule TestServer.Plug.Cowboy.Handler do
   end
 
   @impl true
-  def websocket_handle(frame, {socket, state}) do
+  def websocket_handle(frame, {{instance, _route_ref} = socket, state}) do
     case Instance.dispatch(socket, {:websocket, {:handle, frame}, state}) do
       {:ok, result} ->
         handle_reply(result, socket)
 
       {:error, :not_found} ->
         message =
-          "Unexpected message received for WebSocket"
+          "#{Instance.format_instance(instance)} received an unexpected WebSocket frame"
           |> append_formatted_frame(frame)
           |> append_formatted_websocket_handlers(socket)
 
@@ -57,7 +57,7 @@ defmodule TestServer.Plug.Cowboy.Handler do
 
   defp append_formatted_frame(message, frame) do
     """
-    #{message} with frame:
+    #{message}:
 
     #{inspect(frame)}
     """
@@ -72,29 +72,29 @@ defmodule TestServer.Plug.Cowboy.Handler do
     """
     #{message}
 
-    #{format_websocket_handlers(websocket_handlers, instance)}
+    #{format_websocket_handlers(websocket_handlers)}
     """
   end
 
-  defp format_websocket_handlers({[], suspended_websocket_handlers}, instance) do
-    message = "No active websocket handlers for #{inspect(Instance)} #{inspect(instance)}."
+  defp format_websocket_handlers({[], suspended_websocket_handlers}) do
+    message = "No active websocket handlers."
 
     case suspended_websocket_handlers do
       [] ->
         message
 
       websocket_handlers ->
         """
-        #{message} The following websocket handler(s) have been processed:
+        #{message} The following websocket handlers have been processed:
 
         #{Instance.format_routes(websocket_handlers)}"
         """
     end
   end
 
-  defp format_websocket_handlers({active_websocket_handlers, _}, instance) do
+  defp format_websocket_handlers({active_websocket_handlers, _}) do
     """
-    Active websocket handler(s) #{inspect(Instance)} #{inspect(instance)}:
+    Active websocket handlers:
 
     #{Instance.format_websocket_handlers(active_websocket_handlers)}
     """

lib/test_server/plug_cowboy/plug.ex

@@ -18,7 +18,7 @@ defmodule TestServer.Plug.Cowboy.Plug do
 
       {:error, {:not_found, conn}} ->
         message =
-          "Unexpected #{conn.method} request received at #{conn.request_path}"
+          "#{Instance.format_instance(instance)} received an unexpected #{conn.method} request at #{conn.request_path}"
           |> append_formatted_params(conn)
           |> append_formatted_routes(instance)
 
@@ -49,29 +49,29 @@ defmodule TestServer.Plug.Cowboy.Plug do
     """
     #{message}
 
-    #{format_routes(routes, instance)}
+    #{format_routes(routes)}
     """
   end
 
-  defp format_routes({[], suspended_routes}, instance) do
-    message = "No active routes for #{inspect(Instance)} #{inspect(instance)}."
+  defp format_routes({[], suspended_routes}) do
+    message = "No active routes."
 
     case suspended_routes do
       [] ->
         message
 
       suspended_routes ->
         """
-        #{message} The following route(s) have been processed:
+        #{message} The following routes have been processed:
 
         #{Instance.format_routes(suspended_routes)}
         """
     end
   end
 
-  defp format_routes({active_routes, _suspended_routes}, instance) do
+  defp format_routes({active_routes, _suspended_routes}) do
     """
-    Active route(s) for #{inspect(Instance)} #{inspect(instance)}:
+    Active routes:
 
     #{Instance.format_routes(active_routes)}
     """

test/test_server_test.exs

@@ -70,7 +70,7 @@ defmodule TestServerTest do
         TestServer.stop()
       end
 
-      assert_raise RuntimeError, ~r/The TestServer.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         {:ok, instance} = TestServer.start()
 
         assert :ok = TestServer.stop()
@@ -131,7 +131,7 @@ defmodule TestServerTest do
         TestServer.url()
       end
 
-      assert_raise RuntimeError, ~r/The TestServer.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         {:ok, instance} = TestServer.start()
 
         assert :ok = TestServer.stop()
@@ -172,7 +172,7 @@ defmodule TestServerTest do
 
   describe "add/3" do
     test "when instance not running" do
-      assert_raise RuntimeError, ~r/The TestServer.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         {:ok, instance} = TestServer.start()
 
         assert :ok = TestServer.stop()
@@ -217,7 +217,7 @@ defmodule TestServerTest do
         end
       end
 
-      assert capture_io(fn -> ExUnit.run() end) =~ "Unexpected GET request received at /path."
+      assert capture_io(fn -> ExUnit.run() end) =~ "received an unexpected GET request at /path."
     end
 
     test "with mismatching method" do
@@ -232,7 +232,7 @@ defmodule TestServerTest do
         end
       end
 
-      assert capture_io(fn -> ExUnit.run() end) =~ "Unexpected GET request received at /."
+      assert capture_io(fn -> ExUnit.run() end) =~ "received an unexpected GET request at /."
     end
 
     test "with too many requests" do
@@ -249,7 +249,7 @@ defmodule TestServerTest do
       end
 
       assert captured_io = capture_io(fn -> ExUnit.run() end)
-      assert captured_io =~ "Unexpected GET request received at / with params:"
+      assert captured_io =~ "received an unexpected GET request at / with params:"
       assert captured_io =~ "query_params: %{\"a\" => \"1\"}"
     end
 
@@ -263,7 +263,7 @@ defmodule TestServerTest do
       end
 
       assert capture_io(fn -> ExUnit.run() end) =~
-               ~r/The test ended before the following TestServer\.Instance \#PID\<[0-9.]+\> route\(s\) received a request/
+               "did not receive a request for these routes before the test ended:"
     end
 
     test "with callback plug" do
@@ -404,7 +404,7 @@ defmodule TestServerTest do
         TestServer.x509_suite()
       end
 
-      assert_raise RuntimeError, ~r/The TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         {:ok, instance} = TestServer.start()
 
         assert :ok = TestServer.stop()
@@ -417,7 +417,7 @@ defmodule TestServerTest do
       TestServer.start()
 
       assert_raise RuntimeError,
-                   "The TestServer.Instance is not running with `[scheme: :https]` option",
+                   ~r/TestServer\.Instance \#PID\<[0-9.]+\> is not running with `\[scheme: :https\]` option/,
                    fn ->
                      TestServer.x509_suite()
                    end
@@ -434,9 +434,11 @@ defmodule TestServerTest do
 
       TestServer.start(scheme: :https, cowboy_options: cowboy_options)
 
-      assert_raise RuntimeError, ~r/The TestServer\.Instance is running with custom SSL/, fn ->
-        TestServer.x509_suite()
-      end
+      assert_raise RuntimeError,
+                   ~r/TestServer\.Instance \#PID\<[0-9.]+\> is running with custom SSL/,
+                   fn ->
+                     TestServer.x509_suite()
+                   end
     end
   end
 
@@ -445,7 +447,7 @@ defmodule TestServerTest do
       {:ok, instance} = TestServer.start()
       assert :ok = TestServer.stop()
 
-      assert_raise RuntimeError, ~r/The TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         TestServer.websocket_init(instance, "/ws")
       end
     end
@@ -474,7 +476,7 @@ defmodule TestServerTest do
       assert {:ok, socket} = TestServer.websocket_init("/ws")
       assert :ok = TestServer.stop(instance)
 
-      assert_raise RuntimeError, ~r/The TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         TestServer.websocket_handle(socket)
       end
     end
@@ -501,10 +503,10 @@ defmodule TestServerTest do
       end
 
       assert capture_io(fn -> ExUnit.run() end) =~
-               ~r/The test ended before the following TestServer\.Instance \#PID\<[0-9.]+\> websocket handler\(s\) received a message/
+               "did not receive a frame for these websocket handlers before the test ended:"
     end
 
-    test "when receiving unexpected message" do
+    test "when receiving unexpected frame" do
       defmodule WebSocketHandleTooManyMessagesTest do
         use ExUnit.Case
 
@@ -516,11 +518,11 @@ defmodule TestServerTest do
           assert WebSocketClient.send_message(client, "ping") == :ok
 
           assert WebSocketClient.send_message(client, "ping") =~
-                   "Unexpected message received for WebSocket"
+                   "received an unexpected WebSocket frame"
         end
       end
 
-      assert capture_io(fn -> ExUnit.run() end) =~ "Unexpected message received for WebSocket"
+      assert capture_io(fn -> ExUnit.run() end) =~ "received an unexpected WebSocket frame"
     end
 
     test "with callback function raising exception" do
@@ -593,7 +595,7 @@ defmodule TestServerTest do
       assert {:ok, socket} = TestServer.websocket_init("/ws")
       assert :ok = TestServer.stop(instance)
 
-      assert_raise RuntimeError, ~r/The TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
+      assert_raise RuntimeError, ~r/TestServer\.Instance \#PID\<[0-9.]+\> is not running/, fn ->
         TestServer.websocket_info(socket)
       end
     end