plum 0.0.1

data/test/plum/test_connection_utils.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+using BinaryString
+
+class ServerConnectionUtilsTest < Minitest::Test
+  def test_server_ping
+    open_server_connection {|con|
+      con.ping("ABCABCAB")
+
+      last = sent_frames.last
+      assert_equal(:ping, last.type)
+      assert_equal([], last.flags)
+      assert_equal("ABCABCAB", last.payload)
+    }
+  end
+
+  def test_server_goaway
+    open_server_connection {|con|
+      con << Frame.headers(3, "", :end_stream, :end_headers).assemble
+      con.goaway(:stream_closed)
+
+      last = sent_frames.last
+      assert_equal(:goaway, last.type)
+      assert_equal([], last.flags)
+      assert_equal(3, last.payload.uint32)
+      assert_equal(HTTPError::ERROR_CODES[:stream_closed], last.payload.uint32(4))
+    }
+  end
+end

data/test/plum/test_error.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+
+class ErrorTest < Minitest::Test
+  def test_http_error_http2_error_code
+    test = -> klass {
+      e = klass.new(:cancel)
+      assert_equal(0x08, e.http2_error_code)
+    }
+
+    test.call ConnectionError
+    test.call StreamError
+  end
+end

data/test/plum/test_flow_control.rb

@@ -0,0 +1,167 @@
+require "test_helper"
+
+using BinaryString
+
+class FlowControlTest < Minitest::Test
+  def test_flow_control_window_update_server
+    open_server_connection {|con|
+      before_ws = con.recv_remaining_window
+      con.window_update(500)
+
+      last = sent_frames.last
+      assert_equal(:window_update, last.type)
+      assert_equal(0, last.stream_id)
+      assert_equal(500, last.payload.uint32)
+      assert_equal(before_ws + 500, con.recv_remaining_window)
+    }
+  end
+
+  def test_flow_control_window_update_stream
+    open_new_stream {|stream|
+      before_ws = stream.recv_remaining_window
+      stream.window_update(500)
+
+      last = sent_frames.last
+      assert_equal(:window_update, last.type)
+      assert_equal(stream.id, last.stream_id)
+      assert_equal(500, last.payload.uint32)
+      assert_equal(before_ws + 500, stream.recv_remaining_window)
+    }
+  end
+
+  def test_flow_control_window_update_zero
+    open_new_stream {|stream|
+      assert_stream_error(:protocol_error) {
+        stream.receive_frame Frame.new(type: :window_update,
+                                       stream_id: stream.id,
+                                       payload: "".push_uint32(0))
+      }
+    }
+  end
+
+  def test_flow_control_window_update_frame_size
+    open_new_stream {|stream|
+      assert_connection_error(:frame_size_error) {
+        stream.receive_frame Frame.new(type: :window_update,
+                                       stream_id: stream.id,
+                                       payload: "".push_uint16(0))
+      }
+    }
+  end
+
+  def test_flow_control_dont_send_data_exceeding_send_window
+    open_new_stream {|stream|
+      con = stream.connection
+      con << Frame.new(type: :settings,
+                       stream_id: 0,
+                       payload: "".push_uint16(Frame::SETTINGS_TYPE[:initial_window_size])
+                                  .push_uint32(4*2+1)).assemble
+      # only extend stream window size
+      con << Frame.new(type: :window_update,
+                       stream_id: stream.id,
+                       payload: "".push_uint32(100)).assemble
+      10.times {|i|
+        stream.send Frame.new(type: :data,
+                              stream_id: stream.id,
+                              payload: "".push_uint32(i))
+      }
+
+      last = sent_frames.last
+      assert_equal(1, last.payload.uint32)
+    }
+  end
+
+  def test_flow_control_dont_send_data_upto_updated_send_window
+    open_new_stream {|stream|
+      con = stream.connection
+      con << Frame.new(type: :settings,
+                       stream_id: 0,
+                       payload: "".push_uint16(Frame::SETTINGS_TYPE[:initial_window_size])
+                                  .push_uint32(4*2+1)).assemble
+      10.times {|i|
+        stream.send Frame.new(type: :data,
+                              stream_id: stream.id,
+                              payload: "".push_uint32(i))
+      }
+      # only extend stream window size
+      con << Frame.new(type: :window_update,
+                       stream_id: stream.id,
+                       payload: "".push_uint32(100)).assemble
+      # and extend connection window size
+      con << Frame.new(type: :window_update,
+                       stream_id: 0,
+                       payload: "".push_uint32(4*2+1)).assemble
+
+      last = sent_frames.last
+      assert_equal(3, last.payload.uint32)
+    }
+  end
+
+  def test_flow_control_update_send_initial_window_size
+    open_new_stream {|stream|
+      con = stream.connection
+      con << Frame.new(type: :settings,
+                       stream_id: 0,
+                       payload: "".push_uint16(Frame::SETTINGS_TYPE[:initial_window_size])
+                                  .push_uint32(4*2+1)).assemble
+      10.times {|i|
+        stream.send Frame.new(type: :data,
+                              stream_id: stream.id,
+                              payload: "".push_uint32(i))
+      }
+      # only extend stream window size
+      con << Frame.new(type: :window_update,
+                       stream_id: stream.id,
+                       payload: "".push_uint32(100)).assemble
+      # and update initial window size
+      con << Frame.new(type: :settings,
+                       stream_id: 0,
+                       payload: "".push_uint16(Frame::SETTINGS_TYPE[:initial_window_size])
+                                  .push_uint32(4*4+1)).assemble
+
+      last = sent_frames.reverse.find {|f| f.type == :data }
+      assert_equal(3, last.payload.uint32)
+    }
+  end
+
+  def test_flow_control_recv_window_exceeded
+    prepare = ->(&blk) {
+      open_new_stream {|stream|
+        con = stream.connection
+        con.settings(initial_window_size: 24)
+        blk.call(con, stream)
+      }
+    }
+
+    prepare.call {|con, stream|
+      con.window_update(500) # extend only connection
+      con << Frame.headers(stream.id, "", :end_headers).assemble
+      assert_stream_error(:flow_control_error) {
+        con << Frame.data(stream.id, "\x00" * 30, :end_stream).assemble
+      }
+    }
+
+    prepare.call {|con, stream|
+      stream.window_update(500) # extend only stream
+      con << Frame.headers(stream.id, "", :end_headers).assemble
+      assert_connection_error(:flow_control_error) {
+        con << Frame.data(stream.id, "\x00" * 30, :end_stream).assemble
+      }
+    }
+  end
+
+  def test_flow_control_update_recv_initial_window_size
+    open_new_stream {|stream|
+      con = stream.connection
+      con.settings(initial_window_size: 24)
+      stream.window_update(1)
+      con << Frame.headers(stream.id, "", :end_headers).assemble
+      con << Frame.data(stream.id, "\x00" * 20, :end_stream).assemble
+      assert_equal(4, con.recv_remaining_window)
+      assert_equal(5, stream.recv_remaining_window)
+      con.settings(initial_window_size: 60)
+      assert_equal(40, con.recv_remaining_window)
+      assert_equal(41, stream.recv_remaining_window)
+    }
+  end
+end

data/test/plum/test_frame.rb

@@ -0,0 +1,59 @@
+require "test_helper"
+
+class FrameTest < Minitest::Test
+  # Frame.parse!
+  def test_parse_header_uncomplete
+    buffer = "\x00\x00\x00" << "\x00" << "\x00"
+    buffer_orig = buffer.dup
+    assert_nil(Plum::Frame.parse!(buffer))
+    assert_equal(buffer_orig, buffer)
+  end
+
+  def test_parse_body_uncomplete
+    buffer = "\x00\x00\x03" << "\x00" << "\x00" << "\x00\x00\x00\x00" << "ab"
+    buffer_orig = buffer.dup
+    assert_nil(Plum::Frame.parse!(buffer))
+    assert_equal(buffer_orig, buffer)
+  end
+
+  def test_parse
+    # R 0x1, stream_id 0x4, body "abc"
+    buffer = "\x00\x00\x03" << "\x00" << "\x09" << "\x80\x00\x00\x04" << "abc" << "next_frame_data"
+    frame = Plum::Frame.parse!(buffer)
+    assert_equal(3, frame.length)
+    assert_equal(:data, frame.type)
+    assert_equal([:end_stream, :padded], frame.flags)
+    assert_equal(0x04, frame.stream_id)
+    assert_equal("abc", frame.payload)
+    assert_equal("next_frame_data", buffer)
+    assert_equal(true, frame.frozen?)
+  end
+
+  # Frame#assemble
+  def test_assemble
+    frame = Plum::Frame.new(type: :push_promise, flags: [:end_headers, :padded], stream_id: 0x678, payload: "payl")
+    bin = "\x00\x00\x04" << "\x05" << "\x0c" << "\x00\x00\x06\x78" << "payl"
+    assert_equal(bin, frame.assemble)
+  end
+
+  # Frame#generate
+  def test_new
+    frame = Plum::Frame.new(type: :data,
+                            stream_id: 12345,
+                            flags: [:end_stream, :padded],
+                            payload: "ぺいろーど".encode(Encoding::UTF_8))
+    assert_equal("ぺいろーど", frame.payload)
+    assert_equal("ぺいろーど".bytesize, frame.length)
+    assert_equal(:data, frame.type) # DATA
+    assert_equal([:end_stream, :padded], frame.flags) # 0x01 | 0x08
+    assert_equal(12345, frame.stream_id)
+  end
+
+  def test_inspect
+    frame = Plum::Frame.new(type: :data,
+                            stream_id: 12345,
+                            flags: [:end_stream, :padded],
+                            payload: "ぺいろーど")
+    frame.inspect
+  end
+end

data/test/plum/test_frame_factory.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+using Plum::BinaryString
+class FrameFactoryTest < Minitest::Test
+  def test_rst_stream
+    frame = Frame.rst_stream(123, :stream_closed)
+    assert_frame(frame,
+                 type: :rst_stream,
+                 stream_id: 123)
+    assert_equal(HTTPError::ERROR_CODES[:stream_closed], frame.payload.uint32)
+  end
+
+  def test_goaway
+    frame = Frame.goaway(0x55, :stream_closed, "debug")
+    assert_frame(frame,
+                 type: :goaway,
+                 stream_id: 0,
+                 payload: "\x00\x00\x00\x55\x00\x00\x00\x05debug")
+  end
+
+  def test_settings
+    frame = Frame.settings(header_table_size: 0x1010)
+    assert_frame(frame,
+                 type: :settings,
+                 stream_id: 0,
+                 flags: [],
+                 payload: "\x00\x01\x00\x00\x10\x10")
+  end
+
+  def test_settings_ack
+    frame = Frame.settings(:ack)
+    assert_frame(frame,
+                 type: :settings,
+                 stream_id: 0,
+                 flags: [:ack],
+                 payload: "")
+  end
+
+  def test_ping
+    frame = Frame.ping("12345678")
+    assert_frame(frame,
+                 type: :ping,
+                 stream_id: 0,
+                 flags: [],
+                 payload: "12345678")
+  end
+
+  def test_ping_ack
+    frame = Frame.ping(:ack, "12345678")
+    assert_frame(frame,
+                 type: :ping,
+                 stream_id: 0,
+                 flags: [:ack],
+                 payload: "12345678")
+  end
+end

data/test/plum/test_frame_utils.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class FrameUtilsTest < Minitest::Test
+  def test_frame_enough_short
+    frame = Frame.new(type: :data, stream_id: 1, payload: "123")
+    ret = frame.split_data(3)
+    assert_equal(1, ret.size)
+    assert_equal("123", ret.first.payload)
+  end
+
+  def test_frame_unknown
+    frame = Frame.new(type: :settings, stream_id: 1, payload: "123")
+    assert_raises { frame.split_data(2) }
+    assert_raises { frame.split_headers(2) }
+  end
+
+  def test_frame_data
+    frame = Frame.new(type: :data, flags: [:end_stream], stream_id: 1, payload: "12345")
+    ret = frame.split_data(3)
+    assert_equal(2, ret.size)
+    assert_equal("123", ret.first.payload)
+    assert_equal([], ret.first.flags)
+    assert_equal("45", ret.last.payload)
+    assert_equal([:end_stream], ret.last.flags)
+  end
+
+  def test_frame_headers
+    frame = Frame.new(type: :headers, flags: [:priority, :end_stream, :end_headers], stream_id: 1, payload: "1234567")
+    ret = frame.split_headers(3)
+    assert_equal(3, ret.size)
+    assert_equal("123", ret[0].payload)
+    assert_equal([:end_stream, :priority], ret[0].flags)
+    assert_equal("456", ret[1].payload)
+    assert_equal([], ret[1].flags)
+    assert_equal("7", ret[2].payload)
+    assert_equal([:end_headers], ret[2].flags)
+  end
+
+  def test_frame_parse_settings
+    # :header_table_size => 0x1010, :enable_push => 0x00, :header_table_size => 0x1011 (overwrite)
+    frame = Frame.new(type: :settings, flags: [], stream_id: 0, payload: "\x00\x01\x00\x00\x10\x10\x00\x02\x00\x00\x00\x00\x00\x01\x00\x00\x10\x11")
+    ret = frame.parse_settings
+    assert_equal(0x1011, ret[:header_table_size])
+    assert_equal(0x0000, ret[:enable_push])
+  end
+end

data/test/plum/test_https_connection.rb

@@ -0,0 +1,37 @@
+require "test_helper"
+
+using Plum::BinaryString
+
+class HTTPSConnectionNegotiationTest < Minitest::Test
+  def test_server_must_raise_cprotocol_error_invalid_magic_short
+    con = HTTPSConnection.new(StringIO.new)
+    assert_connection_error(:protocol_error) {
+      con << "HELLO"
+    }
+  end
+
+  def test_server_must_raise_cprotocol_error_invalid_magic_long
+    con = HTTPSConnection.new(StringIO.new)
+    assert_connection_error(:protocol_error) {
+      con << ("HELLO" * 100) # over 24
+    }
+  end
+
+  def test_server_must_raise_cprotocol_error_non_settings_after_magic
+    con = HTTPSConnection.new(StringIO.new)
+    con << Connection::CLIENT_CONNECTION_PREFACE
+    assert_connection_error(:protocol_error) {
+      con << Frame.new(type: :window_update, stream_id: 0, payload: "".push_uint32(1)).assemble
+    }
+  end
+
+  def test_server_accept_fragmented_magic
+    magic = Connection::CLIENT_CONNECTION_PREFACE
+    con = HTTPSConnection.new(StringIO.new)
+    assert_no_error {
+      con << magic[0...5]
+      con << magic[5..-1]
+      con << Frame.new(type: :settings, stream_id: 0).assemble
+    }
+  end
+end

data/test/plum/test_stream.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+using Plum::BinaryString
+
+class StreamTest < Minitest::Test
+  def test_stream_illegal_frame_type
+    open_new_stream {|stream|
+      assert_connection_error(:protocol_error) {
+        stream.receive_frame(Frame.new(type: :goaway, stream_id: stream.id, payload: "\x00\x00\x00\x00"))
+      }
+    }
+  end
+
+  def test_stream_unknown_frame_type
+    open_new_stream {|stream|
+      assert_no_error {
+        stream.receive_frame(Frame.new(type_value: 0x0f, stream_id: stream.id, payload: "\x00\x00\x00\x00"))
+      }
+    }
+  end
+
+  def test_stream_close
+    open_new_stream(state: :half_closed_local) {|stream|
+      stream.close(:frame_size_error)
+
+      last = sent_frames.last
+      assert_equal(:rst_stream, last.type)
+      assert_equal(StreamError.new(:frame_size_error).http2_error_code, last.payload.uint32)
+      assert_equal(:closed, stream.state)
+    }
+  end
+end