plum 0.0.1

data/test/plum/hpack/test_encoder.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class HPACKEncoderTest < Minitest::Test
+  # C.1.1
+  def test_hpack_encode_integer_small
+    result = new_encoder.__send__(:encode_integer, 10, 5)
+    assert_equal([0b00001010].pack("C*"), result)
+  end
+
+  # C.1.2
+  def test_hpack_encode_integer_big
+    result = new_encoder.__send__(:encode_integer, 1337, 5)
+    assert_equal([0b00011111, 0b10011010, 0b00001010].pack("C*"), result)
+  end
+
+  # C.1.3
+  def test_hpack_encode_integer_8prefix
+    result = new_encoder.__send__(:encode_integer, 42, 8)
+    assert_equal([0b00101010].pack("C*"), result)
+  end
+
+  def test_hpack_encode_single
+    headers = [["custom-key", "custom-header"]]
+    encoded = new_encoder.encode(headers)
+    decoded = new_decoder.decode(encoded)
+    assert_equal(headers, decoded)
+  end
+
+  def test_hpack_encode_multiple
+    headers = [
+      [":method", "GET"],
+      [":scheme", "http"],
+      [":path", "/"],
+      [":authority", "www.example.com"]
+    ]
+    encoded = new_encoder.encode(headers)
+    decoded = new_decoder.decode(encoded)
+    assert_equal(headers, decoded)
+  end
+
+  private
+  def new_decoder(settings_header_table_size = 1 << 31)
+    Plum::HPACK::Decoder.new(settings_header_table_size)
+  end
+
+  def new_encoder(settings_header_table_size = 1 << 31)
+    Plum::HPACK::Encoder.new(settings_header_table_size)
+  end
+end

data/test/plum/hpack/test_huffman.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+class HPACKHuffmanTest < Minitest::Test
+  def test_hpack_huffman_encode
+    text = "\x10\x60\x2a\x1d\x94\x47\x82\x2c\x3d\x19\xbf\x8e\xd9\x24\xba\xe6\xb4\x1a\xe1\x5c\x39\x0f\x61\xf4\x3b\x08\x62\x54\x15\x0c"
+    expected = "\xff\xff\xfe\xdf\xff\xbf\x3f\xff\xff\xf3\xff\xff\xdd\x8b\xff\xf9\xfe\xa0\xff\xff\xff\x5f\xff\xfe\x3f\xff\xfd\x7f\xff\xe5\xff\xcf\xff\xfc\x7f\xff\xe8\xff\xff\xdb\xff\xff\xfe\xdf\xff\xfe\x7f\xff\xc1\xff\xff\xff\xec\x1f\xff\xff\xe7\xfb\xff\xff\xfe\x88\xf7\xff\xff\xff\x97\xff\xff\xf5\x7f"
+    assert_equal(expected.force_encoding(Encoding::BINARY), Plum::HPACK::Huffman.encode(text).force_encoding(Encoding::BINARY))
+  end
+
+  def test_hpack_huffman_decode
+    encoded = "\xff\xff\xfe\xdf\xff\xbf\x3f\xff\xff\xf3\xff\xff\xdd\x8b\xff\xf9\xfe\xa0\xff\xff\xff\x5f\xff\xfe\x3f\xff\xfd\x7f\xff\xe5\xff\xcf\xff\xfc\x7f\xff\xe8\xff\xff\xdb\xff\xff\xfe\xdf\xff\xfe\x7f\xff\xc1\xff\xff\xff\xec\x1f\xff\xff\xe7\xfb\xff\xff\xfe\x88\xf7\xff\xff\xff\x97\xff\xff\xf5\x7f"
+    expected = "\x10\x60\x2a\x1d\x94\x47\x82\x2c\x3d\x19\xbf\x8e\xd9\x24\xba\xe6\xb4\x1a\xe1\x5c\x39\x0f\x61\xf4\x3b\x08\x62\x54\x15\x0c"
+    assert_equal(expected.force_encoding(Encoding::BINARY), Plum::HPACK::Huffman.decode(encoded).force_encoding(Encoding::BINARY))
+  end
+
+  def test_too_long_padding
+    encoded = "\x1c\x64\xff\xff\xff"
+    assert_raises(Plum::HPACKError) {
+      Plum::HPACK::Huffman.decode(encoded)
+    }
+  end
+
+  def test_padding_not_filled
+    encoded = "\x1c\x71\xfe"
+    assert_raises(Plum::HPACKError) {
+      Plum::HPACK::Huffman.decode(encoded)
+    }
+  end
+
+  def test_eos_in_encoded
+    encoded = "\xff\xff\xff\xff" # \xff\xff\xff\xfc + padding
+    assert_raises(Plum::HPACKError) {
+      Plum::HPACK::Huffman.decode(encoded)
+    }
+  end
+end

data/test/plum/stream/test_handle_frame.rb

@@ -0,0 +1,262 @@
+require "test_helper"
+
+using Plum::BinaryString
+
+class StreamHandleFrameTest < Minitest::Test
+  ## DATA
+  def test_stream_handle_data
+    payload = "ABC" * 5
+    open_new_stream(state: :open) {|stream|
+      data = nil
+      stream.on(:data) {|_data| data = _data }
+      stream.receive_frame(Frame.new(type: :data, stream_id: stream.id,
+                                     flags: [], payload: payload))
+      assert_equal(payload, data)
+    }
+  end
+
+  def test_stream_handle_data_padded
+    payload = "ABC" * 5
+    open_new_stream(state: :open) {|stream|
+      data = nil
+      stream.on(:data) {|_data| data = _data }
+      stream.receive_frame(Frame.new(type: :data, stream_id: stream.id,
+                                     flags: [:padded], payload: "".push_uint8(6).push(payload).push("\x00"*6)))
+      assert_equal(payload, data)
+    }
+  end
+
+  def test_stream_handle_data_too_long_padding
+    payload = "ABC" * 5
+    open_new_stream(state: :open) {|stream|
+      assert_connection_error(:protocol_error) {
+        stream.receive_frame(Frame.new(type: :data, stream_id: stream.id,
+                                       flags: [:padded], payload: "".push_uint8(100).push(payload).push("\x00"*6)))
+      }
+    }
+  end
+
+  def test_stream_handle_data_end_stream
+    payload = "ABC" * 5
+    open_new_stream(state: :open) {|stream|
+      stream.receive_frame(Frame.new(type: :data, stream_id: stream.id,
+                                     flags: [:end_stream], payload: payload))
+      assert_equal(:half_closed_remote, stream.state)
+    }
+  end
+
+  def test_stream_handle_data_invalid_state
+    payload = "ABC" * 5
+    open_new_stream(state: :half_closed_remote) {|stream|
+      assert_stream_error(:stream_closed) {
+        stream.receive_frame(Frame.new(type: :data, stream_id: stream.id,
+                                       flags: [:end_stream], payload: payload))
+      }
+    }
+  end
+
+  ## HEADERS
+  def test_stream_handle_headers_single
+    open_new_stream {|stream|
+      headers = nil
+      stream.on(:headers) {|_headers|
+        headers = _headers
+      }
+      stream.receive_frame(Frame.new(type: :headers,
+                                     stream_id: stream.id,
+                                     flags: [:end_headers],
+                                     payload: HPACK::Encoder.new(0).encode([[":path", "/"]])))
+      assert_equal(:open, stream.state)
+      assert_equal([[":path", "/"]], headers)
+    }
+  end
+
+  def test_stream_handle_headers_continuation
+    open_new_stream {|stream|
+      payload = HPACK::Encoder.new(0).encode([[":path", "/"]])
+      headers = nil
+      stream.on(:headers) {|_headers|
+        headers = _headers
+      }
+      stream.receive_frame(Frame.new(type: :headers,
+                                     stream_id: stream.id,
+                                     flags: [:end_stream],
+                                     payload: payload[0..4]))
+      assert_equal(nil, headers) # wait CONTINUATION
+      stream.receive_frame(Frame.new(type: :continuation,
+                                     stream_id: stream.id,
+                                     flags: [:end_headers],
+                                     payload: payload[5..-1]))
+      assert_equal(:half_closed_remote, stream.state)
+      assert_equal([[":path", "/"]], headers)
+    }
+  end
+
+  def test_stream_handle_headers_padded
+    open_new_stream {|stream|
+      payload = HPACK::Encoder.new(0).encode([[":path", "/"]])
+      headers = nil
+      stream.on(:headers) {|_headers|
+        headers = _headers
+      }
+      stream.receive_frame(Frame.new(type: :headers,
+                                     stream_id: stream.id,
+                                     flags: [:end_headers, :padded],
+                                     payload: "".push_uint8(payload.bytesize).push(payload).push("\x00"*payload.bytesize)))
+      assert_equal([[":path", "/"]], headers)
+    }
+  end
+
+  def test_stream_handle_headers_too_long_padding
+    open_new_stream {|stream|
+      payload = HPACK::Encoder.new(0).encode([[":path", "/"]])
+      assert_connection_error(:protocol_error) {
+        stream.receive_frame(Frame.new(type: :headers,
+                                       stream_id: stream.id,
+                                       flags: [:end_headers, :padded],
+                                       payload: "".push_uint8(payload.bytesize+1).push(payload).push("\x00"*(payload.bytesize+1))))
+      }
+    }
+  end
+
+  def test_stream_handle_headers_broken
+    open_new_stream {|stream|
+      payload = "\x00\x01\x02"
+      assert_connection_error(:compression_error) {
+        stream.receive_frame(Frame.new(type: :headers,
+                                       stream_id: stream.id,
+                                       flags: [:end_headers],
+                                       payload: payload))
+      }
+    }
+  end
+
+  def test_stream_handle_headers_state
+    _payload = HPACK::Encoder.new(0).encode([[":path", "/"]])
+    open_new_stream(state: :reserved_local) {|stream|
+      assert_connection_error(:protocol_error) {
+        stream.receive_frame(Frame.new(type: :headers, stream_id: stream.id, flags: [:end_headers, :end_stream], payload: _payload))
+      }
+    }
+    open_new_stream(state: :closed) {|stream|
+      assert_connection_error(:stream_closed) {
+        stream.receive_frame(Frame.new(type: :headers, stream_id: stream.id, flags: [:end_headers, :end_stream], payload: _payload))
+      }
+    }
+    open_new_stream(state: :half_closed_remote) {|stream|
+      assert_stream_error(:stream_closed) {
+        stream.receive_frame(Frame.new(type: :headers, stream_id: stream.id, flags: [:end_headers, :end_stream], payload: _payload))
+      }
+    }
+  end
+
+  def test_stream_handle_headers_priority
+    open_server_connection {|con|
+      parent = open_new_stream(con)
+      stream = open_new_stream(con)
+
+      headers = nil
+      stream.on(:headers) {|_headers| headers = _headers }
+      header_block = HPACK::Encoder.new(0).encode([[":path", "/"]])
+      payload = "".push_uint32((1 << 31) | parent.id)
+                  .push_uint8(50)
+                  .push(header_block)
+      stream.receive_frame(Frame.new(type: :headers,
+                                     stream_id: stream.id,
+                                     flags: [:end_headers, :priority],
+                                     payload: payload))
+      assert_equal(true, stream.exclusive)
+      assert_equal(parent, stream.parent)
+      assert_equal(50, stream.weight)
+      assert_equal([[":path", "/"]], headers)
+    }
+  end
+
+  ## PRIORITY
+  def test_stream_handle_priority
+    open_server_connection {|con|
+      parent = open_new_stream(con)
+      stream = open_new_stream(con)
+
+      payload = "".push_uint32((1 << 31) | parent.id)
+                  .push_uint8(50)
+      stream.receive_frame(Frame.new(type: :priority,
+                                     stream_id: stream.id,
+                                     payload: payload))
+      assert_equal(true, stream.exclusive)
+      assert_equal(parent, stream.parent)
+      assert_equal(50, stream.weight)
+    }
+  end
+
+  def test_stream_handle_priority_self_depend
+    open_server_connection {|con|
+      stream = open_new_stream(con)
+      payload = "".push_uint32((1 << 31) | stream.id).push_uint8(6)
+      stream.receive_frame(Frame.new(type: :priority,
+                                     stream_id: stream.id,
+                                     payload: payload))
+      last = sent_frames.last
+      assert_equal(:rst_stream, last.type)
+      assert_equal(HTTPError::ERROR_CODES[:protocol_error], last.payload.uint32)
+    }
+  end
+
+  def test_stream_handle_priority_exclusive
+    open_server_connection {|con|
+      parent = open_new_stream(con)
+      stream0 = open_new_stream(con, parent: parent)
+      stream1 = open_new_stream(con, parent: parent)
+      stream2 = open_new_stream(con, parent: parent)
+
+      payload = "".push_uint32((1 << 31) | parent.id).push_uint8(6)
+      stream0.receive_frame(Frame.new(type: :priority,
+                                      stream_id: stream0.id,
+                                      payload: payload))
+      assert_equal(parent, stream0.parent)
+      assert_equal(stream0, stream1.parent)
+      assert_equal(stream0, stream2.parent)
+    }
+  end
+
+  def test_stream_handle_frame_size_error
+    open_new_stream {|stream|
+      assert_stream_error(:frame_size_error) {
+        stream.receive_frame(Frame.new(type: :priority,
+                                       stream_id: stream.id,
+                                       payload: "\x00"))
+      }
+    }
+  end
+
+  ## RST_STREAM
+  def test_stream_handle_rst_stream
+    open_new_stream(state: :reserved_local) {|stream|
+      stream.receive_frame(Frame.new(type: :rst_stream,
+                                     stream_id: stream.id,
+                                     payload: "\x00\x00\x00\x00"))
+      assert_equal(:closed, stream.state)
+    }
+  end
+
+  def test_stream_handle_rst_stream_idle
+    open_new_stream(state: :idle) {|stream|
+      assert_connection_error(:protocol_error) {
+        stream.receive_frame(Frame.new(type: :rst_stream,
+                                       stream_id: stream.id,
+                                       payload: "\x00\x00\x00\x00"))
+      }
+    }
+  end
+
+  def test_stream_handle_rst_stream_frame_size
+    open_new_stream(state: :reserved_local) {|stream|
+      assert_connection_error(:frame_size_error) {
+        stream.receive_frame(Frame.new(type: :rst_stream,
+                                       stream_id: stream.id,
+                                       payload: "\x00\x00\x00"))
+      }
+    }
+  end
+
+end

data/test/plum/test_binary_string.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+using BinaryString
+
+class BinaryStringTest < Minitest::Test
+  def test_uint8
+    assert_equal(0x67, "\x67".uint8)
+    assert_equal(0x75, "\x67\x75".uint8(1))
+  end
+
+  def test_uint16
+    assert_equal(0x78ff, "\x78\xff".uint16)
+    assert_equal(0xee55, "\x78\xee\x55".uint16(1))
+  end
+
+  def test_uint24
+    assert_equal(0x005554, "\x00\x55\x54".uint24)
+    assert_equal(0x005554, "\x2f\xaa\x00\x55\x54".uint24(2))
+  end
+
+  def test_uint32
+    assert_equal(0x00555400, "\x00\x55\x54\x00".uint32)
+    assert_equal(0x00555400, "\x2f\xaa\x00\x55\x54\x00".uint32(2))
+  end
+
+  def test_push_uint8
+    assert_equal("\x24", "".push_uint8(0x24))
+  end
+
+  def test_push_uint16
+    assert_equal("\x24\x11", "".push_uint16(0x2411))
+  end
+
+  def test_push_uint24
+    assert_equal("\x11\x11\x24", "".push_uint24(0x111124))
+  end
+
+  def test_push_uint32
+    assert_equal("\x10\x00\x00\x24", "".push_uint32(0x10000024))
+  end
+
+  def test_push
+    assert_equal("adh", "ad".push("h"))
+  end
+
+  def test_byteshift
+    sushi = "\u{1f363}".encode(Encoding::UTF_8)
+    assert_equal("\xf0".b, sushi.byteshift(1).b)
+    assert_equal("\x9f\x8d\xa3".b, sushi.b)
+  end
+
+  def test_each_byteslice_block
+    ret = []
+    string = "12345678"
+    string.each_byteslice(3) {|part| ret << part }
+    assert_equal(["123", "456", "78"], ret)
+  end
+
+  def test_each_byteslice_enume
+    string = "12345678"
+    ret = string.each_byteslice(3)
+    assert_equal(["123", "456", "78"], ret.to_a)
+  end
+end

data/test/plum/test_connection.rb

@@ -0,0 +1,96 @@
+require "test_helper"
+
+using Plum::BinaryString
+
+class ConnectionTest < Minitest::Test
+  def test_server_must_raise_frame_size_error_when_exeeeded_max_size
+    _settings = "".push_uint16(Frame::SETTINGS_TYPE[:max_frame_size]).push_uint32(2**14)
+    limit = 2 ** 14
+
+    new_con = -> (&blk) {
+      c = open_server_connection
+      c.settings(max_frame_size: limit)
+      blk.call c
+    }
+
+    new_con.call {|con|
+      assert_no_error {
+        con << Frame.new(type: :settings, stream_id: 0, payload: _settings * (limit / 6)).assemble
+      }
+    }
+    new_con.call {|con|
+      assert_connection_error(:frame_size_error) {
+        con << Frame.new(type: :settings, stream_id: 0, payload: _settings * (limit / 6 + 1)).assemble
+      }
+    }
+
+    new_con.call {|con|
+      assert_connection_error(:frame_size_error) {
+        con << Frame.new(type: :headers, stream_id: 3, payload: "\x00" * (limit + 1)).assemble
+      }
+    }
+    new_con.call {|con|
+      assert_stream_error(:frame_size_error) {
+        con << Frame.new(type: :headers, stream_id: 3, flags: [:end_headers], payload: "").assemble
+        con << Frame.new(type: :data, stream_id: 3, payload: "\x00" * (limit + 1)).assemble
+      }
+    }
+  end
+
+  def test_server_raise_cprotocol_error_illegal_control_stream
+    [:data, :headers, :priority, :rst_stream, :push_promise, :continuation].each do |type|
+      con = open_server_connection
+      assert_connection_error(:protocol_error) {
+        con << Frame.new(type: type, stream_id: 0).assemble
+      }
+    end
+  end
+
+  def test_server_ignore_unknown_frame_type
+    open_server_connection {|con|
+      assert_no_error {
+        con << "\x00\x00\x00\x0f\x00\x00\x00\x00\x00" # type: 0x0f, no flags, no payload, stream 0
+      }
+    }
+  end
+
+  def test_server_raise_cprotocol_error_client_start_even_stream_id
+    con = open_server_connection
+    assert_connection_error(:protocol_error) {
+      con << Frame.new(type: :headers, flags: [:end_headers], stream_id: 2).assemble
+    }
+  end
+
+  def test_server_raise_cprotocol_error_client_start_small_stream_id
+    con = open_server_connection
+    con << Frame.new(type: :headers, flags: [:end_headers], stream_id: 51).assemble
+    assert_connection_error(:protocol_error) {
+      con << Frame.new(type: :headers, flags: [:end_headers], stream_id: 31).assemble
+    }
+  end
+
+  def test_server_raise_cprotocol_error_invalid_continuation_state
+    prepare = -> &blk {
+      con = open_server_connection
+      con << Frame.new(type: :headers, flags: [:end_headers], stream_id: 1).assemble
+      con << Frame.new(type: :headers, flags: [:end_stream], stream_id: 3).assemble
+      blk.call(con)
+    }
+
+    prepare.call {|con|
+      assert_connection_error(:protocol_error) {
+        con << Frame.new(type: :data, stream_id: 1, payload: "hello").assemble
+      }
+    }
+    prepare.call {|con|
+      assert_connection_error(:protocol_error) {
+        con << Frame.new(type: :data, stream_id: 3, payload: "hello").assemble
+      }
+    }
+    prepare.call {|con|
+      assert_equal(:waiting_continuation, con.state)
+      con << Frame.new(type: :continuation, flags: [:end_headers], stream_id: 3, payload: "hello").assemble
+      assert_equal(:open, con.state)
+    }
+  end
+end