test: added some Processor tests

Also: added debug data for various errors (DATA, PING, WINDOW_UPDATE)

lib/connection.ex

@@ -176,12 +176,12 @@ defmodule Kadabra.Connection do
       {:ok, state} ->
         {:noreply, [], state}
 
-      {:connection_error, error, state} ->
+      {:connection_error, error, reason, state} ->
         code = Error.code(error)
 
         bin =
           state.flow_control.stream_set.stream_id
-          |> Goaway.new(code)
+          |> Goaway.new(code, reason)
           |> Encodable.to_bin()
 
         Socket.send(config.socket, bin)

lib/connection/processor.ex

@@ -38,15 +38,16 @@ defmodule Kadabra.Connection.Processor do
           | Continuation.t()
 
   @spec process(frame, Connection.t()) ::
-          {:ok, Connection.t()} | {:connection_error, atom, Connection.t()}
+          {:ok, Connection.t()}
+          | {:connection_error, atom, binary, Connection.t()}
   def process(bin, state) when is_binary(bin) do
     Logger.info("Got binary: #{inspect(bin)}")
     state
   end
 
   def process(%Data{stream_id: 0}, state) do
-    # This is an error
-    {:ok, state}
+    reason = "Recv DATA with stream ID of 0"
+    {:connection_error, :PROTOCOL_ERROR, reason, state}
   end
 
   def process(%Data{stream_id: stream_id} = frame, %{config: config} = state) do
@@ -70,7 +71,7 @@ defmodule Kadabra.Connection.Processor do
         {:ok, state}
 
       {:connection_error, error} ->
-        {:connection_error, error, state}
+        {:connection_error, error, nil, state}
     end
   end
 
@@ -163,11 +164,13 @@ defmodule Kadabra.Connection.Processor do
   end
 
   def process(%Ping{stream_id: sid}, state) when sid != 0 do
-    {:connection_error, :PROTOCOL_ERROR, state}
+    reason = "Recv PING with stream ID of #{sid}"
+    {:connection_error, :PROTOCOL_ERROR, reason, state}
   end
 
   def process(%Ping{data: data}, state) when byte_size(data) != 8 do
-    {:connection_error, :FRAME_SIZE_ERROR, state}
+    reason = "Recv PING with payload of #{byte_size(data)} bytes"
+    {:connection_error, :FRAME_SIZE_ERROR, reason, state}
   end
 
   def process(%Ping{ack: false}, %{config: config} = state) do
@@ -182,12 +185,13 @@ defmodule Kadabra.Connection.Processor do
 
   def process(%Goaway{} = frame, state) do
     log_goaway(frame)
-    {:connection_error, :NO_ERROR, state}
+    {:connection_error, :NO_ERROR, nil, state}
   end
 
   def process(%WindowUpdate{stream_id: 0, window_size_increment: inc}, state)
       when inc <= 0 do
-    {:connection_error, :PROTOCOL_ERROR, state}
+    reason = "Recv WINDOW_UPDATE with increment of #{inc}"
+    {:connection_error, :PROTOCOL_ERROR, reason, state}
   end
 
   def process(%WindowUpdate{stream_id: 0, window_size_increment: inc}, state) do

lib/frame/goaway.ex

@@ -45,9 +45,14 @@ defmodule Kadabra.Frame.Goaway do
   end
 
   def new(stream_id, error_code) when is_integer(stream_id) do
+    new(stream_id, error_code, nil)
+  end
+
+  def new(stream_id, error_code, reason) when is_integer(stream_id) do
     %__MODULE__{
       last_stream_id: stream_id,
-      error_code: error_code
+      error_code: error_code,
+      debug_data: reason
     }
   end
 end

lib/request.ex

@@ -5,8 +5,11 @@ defmodule Kadabra.Request do
   Useful when queueing multiple requests at once through
   `Kadabra.request/2`
   """
+
   defstruct headers: [], body: nil, on_response: nil
 
+  alias Kadabra.Stream.Response
+
   @type t :: %__MODULE__{
           headers: [],
           body: binary,

test/connection/processor_test.exs

@@ -0,0 +1,51 @@
+defmodule Kadabra.Connection.ProcessorTest do
+  use ExUnit.Case
+
+  alias Kadabra.Connection
+  alias Kadabra.Connection.Processor
+  alias Kadabra.Frame.{Data, Ping, WindowUpdate}
+
+  defp conn do
+    %Connection{
+      config: %{
+        client: self()
+      },
+      flow_control: %Connection.FlowControl{}
+    }
+  end
+
+  test "throws connection error on non-zero DATA stream_id" do
+    bad = %Data{stream_id: 0}
+
+    assert {:connection_error, :PROTOCOL_ERROR, _, _} =
+             Processor.process(bad, conn())
+  end
+
+  describe "process PING" do
+    test "throws connection error on non-zero stream_id" do
+      bad = %Ping{stream_id: 1}
+
+      assert {:connection_error, :PROTOCOL_ERROR, _, _} =
+               Processor.process(bad, conn())
+    end
+
+    test "throws connection error if payload not 8 bytes" do
+      bad = %Ping{data: <<0, 1>>}
+
+      assert {:connection_error, :FRAME_SIZE_ERROR, _, _} =
+               Processor.process(bad, conn())
+    end
+  end
+
+  describe "process WINDOW_UPDATE" do
+    test "throws connection error zero or negative increment" do
+      bad = %WindowUpdate{window_size_increment: 0, stream_id: 0}
+      bad_2 = %WindowUpdate{window_size_increment: -5, stream_id: 0}
+
+      for b <- [bad, bad_2] do
+        assert {:connection_error, :PROTOCOL_ERROR, _, _} =
+                 Processor.process(b, conn())
+      end
+    end
+  end
+end