biryani 0.0.1

data/spec/connection/send_spec.rb

@@ -0,0 +1,114 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'send' do
+    let(:io) do
+      StringIO.new
+    end
+    let(:data_buffer) do
+      DataBuffer.new
+    end
+
+    let(:headers1) do
+      Frame::Headers.new(true, false, 2, nil, nil, 'this is dummy', nil)
+    end
+    let(:data1) do
+      Frame::Data.new(true, 2, 'Hello, world!', 'Howdy!')
+    end
+    let(:send_window1) do
+      Window.new
+    end
+    let(:streams_ctx1) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should send' do
+      streams_ctx1[2].state.transition!(headers1, :recv)
+      streams_ctx1[2].state.transition!(data1, :recv)
+      Connection.send(io, headers1, send_window1, streams_ctx1, data_buffer)
+      Connection.send(io, data1, send_window1, streams_ctx1, data_buffer)
+      expect(io.string).to eq "\x00\x00\x0d\x01\x04\x00\x00\x00\x02this is dummy\x00\x00\x14\x00\x09\x00\x00\x00\x02\x06\x48\x65\x6c\x6c\x6f\x2c\x20\x77\x6f\x72\x6c\x64\x21\x48\x6f\x77\x64\x79\x21".b
+      expect(send_window1.length).to eq 2**16 - 21
+      expect(streams_ctx1[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx1[2].send_window.length).to eq 2**16 - 21
+      expect(data_buffer.length).to eq 0
+    end
+
+    let(:headers2) do
+      Frame::Headers.new(true, true, 1, nil, nil, 'this is dummy', nil)
+    end
+    let(:send_window2) do
+      Window.new
+    end
+    let(:streams_ctx2) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should send' do
+      streams_ctx2[1].state.transition!(headers2, :recv)
+      Connection.send(io, headers2, send_window2, streams_ctx2, data_buffer)
+      expect(io.string).to eq "\x00\x00\x0d\x01\x05\x00\x00\x00\x01\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b
+      expect(send_window2.length).to eq 2**16 - 1
+      expect(streams_ctx2[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx2[2].send_window.length).to eq 2**16 - 1
+      expect(data_buffer.length).to eq 0
+    end
+
+    let(:headers3) do
+      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy', nil)
+    end
+    let(:data3) do
+      Frame::Data.new(false, 2, 'Hello, world!', 'Howdy!')
+    end
+    let(:send_window3) do
+      Window.new
+    end
+    let(:streams_ctx3) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx[2].send_window.consume!(2**16 - 1)
+      streams_ctx
+    end
+    it 'should send' do
+      streams_ctx3[2].state.transition!(headers3, :recv)
+      Connection.send(io, data3, send_window3, streams_ctx3, data_buffer)
+      expect(io.string).to eq ''
+      expect(send_window3.length).to eq 2**16 - 1
+      expect(streams_ctx3[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx3[2].send_window.length).to eq 0
+      expect(data_buffer.length).to eq 1
+    end
+
+    let(:headers4) do
+      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy', nil)
+    end
+    let(:data4) do
+      Frame::Data.new(false, 2, 'Hello, world!', 'Howdy!')
+    end
+    let(:send_window4) do
+      send_window = Window.new
+      send_window.consume!(2**16 - 1)
+      send_window
+    end
+    let(:streams_ctx4) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should send' do
+      streams_ctx4[2].state.transition!(headers4, :recv)
+      Connection.send(io, data4, send_window4, streams_ctx4, data_buffer)
+      expect(io.string).to eq ''
+      expect(send_window4.length).to eq 0
+      expect(streams_ctx4[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx4[2].send_window.length).to eq 2**16 - 1
+      expect(data_buffer.length).to eq 1
+    end
+  end
+end

data/spec/connection/transition_state_send_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'transition_state_send' do
+    let(:streams_ctx) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+
+    let(:headers) do
+      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy', nil)
+    end
+    it 'should transition' do
+      streams_ctx[2].state.transition!(headers, :recv)
+      Connection.transition_state_send(headers, streams_ctx)
+      expect(streams_ctx.length).to eq 2
+    end
+
+    it 'should transition' do
+      streams_ctx[1].state.transition!(headers, :recv)
+      streams_ctx[2].state.transition!(headers, :recv)
+      Connection.close_all_streams(streams_ctx)
+      expect { streams_ctx[1].tx << nil }.to raise_error Ractor::ClosedError
+      expect { streams_ctx[2].tx << nil }.to raise_error Ractor::ClosedError
+    end
+
+    let(:rst_stream) do
+      Frame::RstStream.new(2, 0)
+    end
+    it 'should transition' do
+      streams_ctx[2].state.transition!(headers, :recv)
+      Connection.transition_state_send(rst_stream, streams_ctx)
+      expect { streams_ctx[1].tx << nil }.to_not raise_error
+      expect { streams_ctx[2].tx << nil }.to_not raise_error
+    end
+  end
+end

data/spec/connection/unwrap_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'unwrap' do
+    let(:data) do
+      Frame::Data.new(false, 2, 'Hello, world!', 'Howdy!')
+    end
+    it 'should ensure' do
+      expect(Connection.unwrap(data, 0x01)).to eq data
+    end
+
+    let(:connection_error) do
+      ConnectionError.new(ErrorCode::NO_ERROR, 'debug')
+    end
+    it 'should ensure' do
+      frame = Connection.unwrap(connection_error, 0x01)
+      expect(frame).to be_kind_of Frame::Goaway
+    end
+
+    let(:stream_error) do
+      StreamError.new(ErrorCode::NO_ERROR, 0x01, 'debug')
+    end
+    it 'should ensure' do
+      frame = Connection.unwrap(stream_error, 0x01)
+      expect(frame).to be_kind_of Frame::RstStream
+    end
+  end
+end

data/spec/data_buffer_spec.rb

@@ -0,0 +1,135 @@
+require_relative 'spec_helper'
+
+RSpec.describe DataBuffer do
+  context 'take!' do
+    let(:data_buffer1) do
+      DataBuffer.new
+    end
+    let(:send_window1) do
+      Window.new
+    end
+    let(:streams_ctx1) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should take' do
+      expect(data_buffer1.take!(send_window1, streams_ctx1).length).to eq 0
+      expect(send_window1.length).to eq 2**16 - 1
+      expect(streams_ctx1[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx1[2].send_window.length).to eq 2**16 - 1
+    end
+
+    let(:data_buffer2) do
+      data_buffer = DataBuffer.new
+      data_buffer << Frame::Data.new(false, 1, 'one', nil)
+      data_buffer << Frame::Data.new(false, 2, 'two', nil)
+      data_buffer
+    end
+    let(:send_window2) do
+      Window.new
+    end
+    let(:streams_ctx2) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should take' do
+      datas = data_buffer2.take!(send_window2, streams_ctx2)
+      expect(datas.length).to eq 2
+      expect(datas.map(&:stream_id)).to eq [1, 2]
+      expect(datas.map(&:data)).to eq %w[one two]
+      expect(send_window2.length).to eq 2**16 - 7
+      expect(streams_ctx2[1].send_window.length).to eq 2**16 - 4
+      expect(streams_ctx2[2].send_window.length).to eq 2**16 - 4
+    end
+
+    let(:data_buffer3) do
+      data_buffer = DataBuffer.new
+      data_buffer << Frame::Data.new(false, 2, 'two', nil)
+      data_buffer
+    end
+    let(:send_window3) do
+      Window.new
+    end
+    let(:streams_ctx3) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should take' do
+      datas = data_buffer3.take!(send_window3, streams_ctx3)
+      expect(datas.length).to eq 1
+      expect(datas.first.stream_id).to eq 2
+      expect(datas.first.data).to eq 'two'
+      expect(send_window3.length).to eq 2**16 - 4
+      expect(streams_ctx3[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx3[2].send_window.length).to eq 2**16 - 4
+    end
+
+    let(:data_buffer4) do
+      data_buffer = DataBuffer.new
+      data_buffer << Frame::Data.new(false, 1, 'one', nil)
+      data_buffer << Frame::Data.new(false, 2, 'two', nil)
+      data_buffer
+    end
+    let(:send_window4) do
+      Window.new
+    end
+    let(:streams_ctx4) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx[1].send_window.consume!(2**16 - 1)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should take' do
+      datas = data_buffer4.take!(send_window4, streams_ctx4)
+      expect(datas.length).to eq 1
+      expect(datas.first.stream_id).to eq 2
+      expect(datas.first.data).to eq 'two'
+      expect(send_window4.length).to eq 2**16 - 4
+      expect(streams_ctx4[1].send_window.length).to eq 0
+      expect(streams_ctx4[2].send_window.length).to eq 2**16 - 4
+    end
+
+    let(:data_buffer5) do
+      data_buffer = DataBuffer.new
+      data_buffer << Frame::Data.new(false, 1, 'one', nil)
+      data_buffer << Frame::Data.new(false, 2, 'two', nil)
+      data_buffer
+    end
+    let(:send_window5) do
+      send_window = Window.new
+      send_window.consume!(2**16 - 1)
+      send_window
+    end
+    let(:streams_ctx5) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should take' do
+      expect(data_buffer5.take!(send_window5, streams_ctx5).length).to eq 0
+      expect(send_window5.length).to eq 0
+      expect(streams_ctx5[1].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx5[2].send_window.length).to eq 2**16 - 1
+    end
+  end
+
+  context 'has?' do
+    let(:data_buffer6) do
+      data_buffer = DataBuffer.new
+      data_buffer << Frame::Data.new(false, 1, 'one', nil)
+      data_buffer
+    end
+    it 'should take' do
+      expect(data_buffer6.has?(1)).to eq true
+      expect(data_buffer6.has?(2)).to eq false
+    end
+  end
+end

data/spec/frame/continuation_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Continuation do
+  context do
+    let(:continuation1) do
+      Frame::Continuation.new(false, 50, '')
+    end
+    it 'should encode' do
+      expect(continuation1.to_binary_s).to eq "\x00\x00\x00\x09\x00\x00\x00\x00\x32".b
+    end
+
+    let(:continuation2) do
+      Frame::Continuation.new(false, 50, 'this is dummy')
+    end
+    it 'should encode' do
+      expect(continuation2.to_binary_s).to eq "\x00\x00\x0d\x09\x00\x00\x00\x00\x32\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b
+    end
+
+    let(:continuation3) do
+      Frame::Continuation.read("\x00\x00\x00\x09\x00\x00\x00\x00\x32".b)
+    end
+    it 'should decode' do
+      expect(continuation3.f_type).to eq FrameType::CONTINUATION
+      expect(continuation3.end_headers?).to eq false
+      expect(continuation3.stream_id).to eq 50
+      expect(continuation3.fragment).to eq ''
+    end
+
+    let(:continuation4) do
+      Frame::Continuation.read("\x00\x00\x0d\x09\x00\x00\x00\x00\x32\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b)
+    end
+    it 'should decode' do
+      expect(continuation4.f_type).to eq FrameType::CONTINUATION
+      expect(continuation4.end_headers?).to eq false
+      expect(continuation4.stream_id).to eq 50
+      expect(continuation4.fragment).to eq 'this is dummy'
+    end
+  end
+end

data/spec/frame/data_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Data do
+  context do
+    let(:data1) do
+      Frame::Data.new(false, 2, 'Hello, world!', 'Howdy!')
+    end
+    it 'should encode' do
+      expect(data1.to_binary_s).to eq "\x00\x00\x14\x00\x08\x00\x00\x00\x02\x06\x48\x65\x6c\x6c\x6f\x2c\x20\x77\x6f\x72\x6c\x64\x21\x48\x6f\x77\x64\x79\x21".b
+    end
+
+    let(:data2) do
+      Frame::Data.read("\x00\x00\x14\x00\x08\x00\x00\x00\x02\x06\x48\x65\x6c\x6c\x6f\x2c\x20\x77\x6f\x72\x6c\x64\x21\x48\x6f\x77\x64\x79\x21".b)
+    end
+    it 'should decode' do
+      expect(data2.f_type).to eq FrameType::DATA
+      expect(data2.end_stream?).to eq false
+      expect(data2.stream_id).to eq 2
+      expect(data2.data).to eq 'Hello, world!'
+      expect(data2.padding).to eq 'Howdy!'
+      expect(data2.padded?).to eq true
+      expect(data2.length).to eq 20
+    end
+  end
+end

data/spec/frame/goaway_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Goaway do
+  context do
+    let(:goaway1) do
+      Frame::Goaway.new(0, 30, 9, 'hpack is broken')
+    end
+    it 'should encode' do
+      expect(goaway1.to_binary_s).to eq "\x00\x00\x17\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x09\x68\x70\x61\x63\x6b\x20\x69\x73\x20\x62\x72\x6f\x6b\x65\x6e".b
+    end
+
+    let(:goaway2) do
+      Frame::Goaway.read("\x00\x00\x17\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x09\x68\x70\x61\x63\x6b\x20\x69\x73\x20\x62\x72\x6f\x6b\x65\x6e".b)
+    end
+    it 'should decode' do
+      expect(goaway2.f_type).to eq FrameType::GOAWAY
+      expect(goaway2.stream_id).to eq 0
+      expect(goaway2.last_stream_id).to eq 30
+      expect(goaway2.error_code).to eq 9
+      expect(goaway2.debug).to eq 'hpack is broken'
+    end
+  end
+end

data/spec/frame/headers_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Headers do
+  context do
+    let(:headers1) do
+      Frame::Headers.new(true, false, 1, nil, nil, 'this is dummy', nil)
+    end
+    it 'should encode' do
+      expect(headers1.to_binary_s).to eq "\x00\x00\x0d\x01\x04\x00\x00\x00\x01\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b
+    end
+
+    let(:headers2) do
+      Frame::Headers.new(true, false, 3, 20, 10, 'this is dummy', 'This is padding.')
+    end
+    it 'should encode' do
+      expect(headers2.to_binary_s)
+        .to eq "\x00\x00\x23\x01\x2c\x00\x00\x00\x03\x10\x00\x00\x00\x14\x0a\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x54\x68\x69\x73\x20\x69\x73\x20\x70\x61\x64\x64\x69\x6e\x67\x2e".b
+    end
+
+    let(:headers3) do
+      Frame::Headers.read("\x00\x00\x0d\x01\x04\x00\x00\x00\x01\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b)
+    end
+    it 'should decode' do
+      expect(headers3.f_type).to eq FrameType::HEADERS
+      expect(headers3.end_headers?).to eq true
+      expect(headers3.end_stream?).to eq false
+      expect(headers3.stream_id).to eq 1
+      expect(headers3.stream_dependency).to eq nil
+      expect(headers3.weight).to eq nil
+      expect(headers3.fragment).to eq 'this is dummy'
+      expect(headers3.padding).to eq nil
+      expect(headers3.priority?).to eq false
+      expect(headers3.padded?).to eq false
+    end
+
+    let(:headers4) do
+      Frame::Headers.read("\x00\x00\x23\x01\x2c\x00\x00\x00\x03\x10\x00\x00\x00\x14\x0a\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x54\x68\x69\x73\x20\x69\x73\x20\x70\x61\x64\x64\x69\x6e\x67\x2e".b)
+    end
+    it 'should decode' do
+      expect(headers4.f_type).to eq FrameType::HEADERS
+      expect(headers4.end_headers?).to eq true
+      expect(headers4.end_stream?).to eq false
+      expect(headers4.stream_id).to eq 3
+      expect(headers4.stream_dependency).to eq 20
+      expect(headers4.weight).to eq 10
+      expect(headers4.fragment).to eq 'this is dummy'
+      expect(headers4.padding).to eq 'This is padding.'
+      expect(headers4.priority?).to eq true
+      expect(headers4.padded?).to eq true
+    end
+  end
+end

data/spec/frame/ping_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Ping do
+  context do
+    let(:ping1) do
+      Frame::Ping.new(false, 0, 'deadbeef')
+    end
+    it 'should encode' do
+      expect(ping1.to_binary_s).to eq "\x00\x00\x08\x06\x00\x00\x00\x00\x00\x64\x65\x61\x64\x62\x65\x65\x66".b
+    end
+
+    let(:ping2) do
+      Frame::Ping.read("\x00\x00\x08\x06\x00\x00\x00\x00\x00\x64\x65\x61\x64\x62\x65\x65\x66".b)
+    end
+    it 'should decode' do
+      expect(ping2.f_type).to eq FrameType::PING
+      expect(ping2.ack?).to eq false
+      expect(ping2.stream_id).to eq 0
+      expect(ping2.opaque).to eq 'deadbeef'
+    end
+  end
+end

data/spec/frame/priority_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Priority do
+  context do
+    let(:priority1) do
+      Frame::Priority.new(9, 11, 8)
+    end
+    it 'should encode' do
+      expect(priority1.to_binary_s).to eq "\x00\x00\x05\x02\x00\x00\x00\x00\x09\x00\x00\x00\x0b\x08".b
+    end
+
+    let(:priority2) do
+      Frame::Priority.read("\x00\x00\x05\x02\x00\x00\x00\x00\x09\x00\x00\x00\x0b\x08".b)
+    end
+    it 'should decode' do
+      expect(priority2.f_type).to eq FrameType::PRIORITY
+      expect(priority2.stream_id).to eq 9
+      expect(priority2.stream_dependency).to eq 11
+      expect(priority2.weight).to eq 8
+    end
+  end
+end

data/spec/frame/push_promise_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::PushPromise do
+  context do
+    let(:push_promise1) do
+      Frame::PushPromise.new(true, 10, 12, 'this is dummy', 'Howdy!')
+    end
+    it 'should encode' do
+      expect(push_promise1.to_binary_s).to eq "\x00\x00\x18\x05\x0c\x00\x00\x00\x0a\x06\x00\x00\x00\x0c\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x48\x6f\x77\x64\x79\x21".b
+    end
+
+    let(:push_promise2) do
+      Frame::PushPromise.read("\x00\x00\x18\x05\x0c\x00\x00\x00\x0a\x06\x00\x00\x00\x0c\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x48\x6f\x77\x64\x79\x21".b)
+    end
+    it 'should decode' do
+      expect(push_promise2.f_type).to eq FrameType::PUSH_PROMISE
+      expect(push_promise2.padded?).to eq true
+      expect(push_promise2.stream_id).to eq 10
+      expect(push_promise2.promised_stream_id).to eq 12
+      expect(push_promise2.fragment).to eq 'this is dummy'
+      expect(push_promise2.padding).to eq 'Howdy!'
+    end
+  end
+end

data/spec/frame/read_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame do
+  context do
+    let(:empty) do
+      StringIO.new(''.b)
+    end
+    it 'should not read' do
+      expect(Frame.read(empty)).to eq nil
+    end
+
+    let(:invalid_header) do
+      StringIO.new("\x12\x34\x56\x00\x00".b)
+    end
+    it 'should not read' do
+      expect(Frame.read(invalid_header)).to be_kind_of ConnectionError
+    end
+
+    let(:unknown) do
+      StringIO.new("\x00\x00\x01\x0a\x01\x00\x00\x00\x01\xff".b)
+    end
+    it 'should read' do
+      frame = Frame.read(unknown)
+      expect(frame.f_type).to eq 0x0a
+      expect(frame.flags).to eq 0x01
+      expect(frame.stream_id).to eq 0x01
+      expect(frame.payload).to eq "\xff".b
+    end
+  end
+end

data/spec/frame/rst_stream_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::RstStream do
+  context do
+    let(:rst_stream1) do
+      Frame::RstStream.new(5, 8)
+    end
+    it 'should encode' do
+      expect(rst_stream1.to_binary_s).to eq "\x00\x00\x04\x03\x00\x00\x00\x00\x05\x00\x00\x00\x08".b
+    end
+
+    let(:rst_stream2) do
+      Frame::RstStream.read("\x00\x00\x04\x03\x00\x00\x00\x00\x05\x00\x00\x00\x08".b)
+    end
+    it 'should decode' do
+      expect(rst_stream2.f_type).to eq FrameType::RST_STREAM
+      expect(rst_stream2.stream_id).to eq 5
+      expect(rst_stream2.error_code).to eq 8
+    end
+  end
+end

data/spec/frame/settings_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::Settings do
+  context do
+    let(:settings1) do
+      Frame::Settings.new(false, 0, { 1 => 8192, 3 => 5000 })
+    end
+    it 'should encode' do
+      expect(settings1.to_binary_s).to eq "\x00\x00\x0c\x04\x00\x00\x00\x00\x00\x00\x01\x00\x00\x20\x00\x00\x03\x00\x00\x13\x88".b
+    end
+
+    let(:settings2) do
+      Frame::Settings.read("\x00\x00\x0c\x04\x00\x00\x00\x00\x00\x00\x01\x00\x00\x20\x00\x00\x03\x00\x00\x13\x88".b)
+    end
+    it 'should decode' do
+      expect(settings2.f_type).to eq FrameType::SETTINGS
+      expect(settings2.ack?).to eq false
+      expect(settings2.stream_id).to eq 0
+      expect(settings2.setting[1]).to eq 8192
+      expect(settings2.setting[3]).to eq 5000
+    end
+  end
+end

data/spec/frame/window_update_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+RSpec.describe Frame::WindowUpdate do
+  context do
+    let(:window_update1) do
+      Frame::WindowUpdate.new(50, 1000)
+    end
+    it 'should encode' do
+      expect(window_update1.to_binary_s).to eq "\x00\x00\x04\x08\x00\x00\x00\x00\x32\x00\x00\x03\xe8".b
+    end
+
+    let(:window_update2) do
+      Frame::WindowUpdate.read("\x00\x00\x04\x08\x00\x00\x00\x00\x32\x00\x00\x03\xe8".b)
+    end
+    it 'should decode' do
+      expect(window_update2.f_type).to eq FrameType::WINDOW_UPDATE
+      expect(window_update2.stream_id).to eq 50
+      expect(window_update2.window_size_increment).to eq 1000
+    end
+  end
+end