biryani 0.0.1 → 0.0.3

data/lib/biryani/http_response.rb

@@ -34,28 +34,12 @@ module Biryani
       @res.content
     end
 
-    # @param stream_id [Integer]
     # @param encoder [Encoder]
-    # @param max_frame_size [Integer]
     #
-    # @return [Array<Object>] frames
-    def parse(stream_id, encoder, max_frame_size)
-      fragment = encoder.encode(fields)
-      len = (fragment.bytesize + max_frame_size - 1) / max_frame_size
-      frames = fragment.gsub(/.{1,#{max_frame_size}}/m).with_index.map do |s, index|
-        if index.zero?
-          Frame::Headers.new(len < 2, content.empty?, stream_id, nil, nil, s, nil)
-        else
-          Frame::Continuation.new(index == len - 1, stream_id, s)
-        end
-      end
-
-      len = (content.bytesize + max_frame_size - 1) / max_frame_size
-      frames += content.gsub(/.{1,#{max_frame_size}}/m).with_index.map do |s, index|
-        Frame::Data.new(index == len - 1, stream_id, s, nil)
-      end
-
-      frames
+    # @return [String] fragment
+    # @return [String] data
+    def parse(encoder)
+      [encoder.encode(fields), content]
     end
   end
 end

data/lib/biryani/state.rb

@@ -8,7 +8,7 @@ module Biryani
     # @param direction [:send, :recv]
     def transition!(frame, direction)
       obj = self.class.next(@state, frame, direction)
-      return obj if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+      return obj if Biryani.err?(obj)
 
       @state = obj
     end
@@ -76,6 +76,8 @@ module Biryani
       # receiving_continuation_data
       in [:receiving_continuation_data, FrameType::RST_STREAM, _]
         :closed
+      in [:receiving_continuation_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:receiving_continuation_data, FrameType::CONTINUATION, :recv] if frame.end_headers?
         :receiving_data
       in [:receiving_continuation_data, FrameType::CONTINUATION, :recv]
@@ -86,6 +88,8 @@ module Biryani
       # receiving_continuation
       in [:receiving_continuation, FrameType::RST_STREAM, _]
         :closed
+      in [:receiving_continuation, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:receiving_continuation, FrameType::CONTINUATION, :recv] if frame.end_headers?
         :half_closed_remote
       in [:receiving_continuation, FrameType::CONTINUATION, :recv]
@@ -100,6 +104,8 @@ module Biryani
         state
       in [:receiving_data, FrameType::RST_STREAM, _]
         :closed
+      in [:receiving_data, FrameType::WINDOW_UPDATE, _]
+        state
       in [:receiving_data, _, _]
         unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
 
@@ -126,7 +132,7 @@ module Biryani
         state
       in [:half_closed_remote, FrameType::RST_STREAM, _]
         :closed
-      in [half_closed_remote, FrameType::WINDOW_UPDATE, :recv]
+      in [:half_closed_remote, FrameType::WINDOW_UPDATE, _]
         state
       in [:half_closed_remote, _, :recv]
         unexpected(ErrorCode::STREAM_CLOSED, state, typ, direction)
@@ -136,6 +142,8 @@ module Biryani
       # sending_continuation_data
       in [:sending_continuation_data, FrameType::RST_STREAM, :send]
         :closed
+      in [:sending_continuation_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:sending_continuation_data, FrameType::CONTINUATION, :send] if frame.end_headers?
         :sending_data
       in [:sending_continuation_data, FrameType::CONTINUATION, :send]
@@ -148,6 +156,8 @@ module Biryani
       # sending_continuation
       in [:sending_continuation, FrameType::RST_STREAM, :send]
         :closed
+      in [:sending_continuation, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:sending_continuation, FrameType::CONTINUATION, :send] if frame.end_headers?
         :closed
       in [:sending_continuation, FrameType::CONTINUATION, :send]
@@ -160,6 +170,8 @@ module Biryani
       # sending_data
       in [:sending_data, FrameType::DATA, :send] if frame.end_stream?
         :closed
+      in [:sending_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:sending_data, FrameType::DATA, :send]
         state
       in [:sending_data, FrameType::RST_STREAM, :send]
@@ -213,7 +225,7 @@ module Biryani
 
     # @return [Boolean]
     def active?
-      @state == :open || @state == :half_closed_local || @state == :half_closed_remote
+      !%i[idle reserved_local reserved_remote closed].include?(@state)
     end
 
     # @return [Boolean]

data/lib/biryani/streams_context.rb

@@ -1,15 +1,17 @@
 module Biryani
   class StreamsContext
-    def initialize
-      @h = {}
+    def initialize(proc)
+      @h = {} # Hash<Integer, StreamContext>
+      @proc = proc
     end
 
     # @param stream_id [Integer]
-    # @param proc [Proc]
+    # @param send_initial_window_size [Integer]
+    # @param recv_initial_window_size [Integer]
     #
     # @return [StreamContext]
-    def new_context(stream_id, proc)
-      ctx = StreamContext.new(stream_id, proc)
+    def new_context(stream_id, send_initial_window_size, recv_initial_window_size)
+      ctx = StreamContext.new(stream_id, send_initial_window_size, recv_initial_window_size, @proc)
       @h[stream_id] = ctx
       ctx
     end
@@ -54,18 +56,62 @@ module Biryani
     def last_stream_id
       @h.reject { |_, ctx| ctx.idle? }.keys.max || 0
     end
+
+    # @param stream_id [Integer]
+    # @param data [String]
+    # @param send_window [Window]
+    # @param max_frame_size [Integer]
+    #
+    # @return [Array<Object>] frames
+    # @return [String]
+    def sendable_datas(stream_id, data, send_window, max_frame_size)
+      len = [data.bytesize, send_window.length, @h[stream_id].send_window.length].min
+
+      payload = data[0...len]
+      remains = data[len..] || ''
+
+      len = (len + max_frame_size - 1) / max_frame_size
+      frames = payload.gsub(/.{1,#{max_frame_size}}/m).with_index.map do |s, index|
+        end_stream = remains.empty? && index == len - 1
+        Frame::Data.new(end_stream, stream_id, s, nil)
+      end
+
+      [frames, remains]
+    end
+
+    # @param data_buffer [DataBuffer]
+    def remove_closed(data_buffer)
+      closed_ids = closed_stream_ids.filter { |id| !data_buffer.has?(id) }
+      closed_ids.each do |id|
+        @h[id].tx.close
+        @h[id].stream.rx << nil
+        @h[id].fragment.close
+        @h[id].content.close
+      end
+    end
+
+    def close_all
+      each do |ctx|
+        ctx.tx.close
+        ctx.fragment.close
+        ctx.content.close
+        ctx.state.close
+      end
+    end
   end
 
   class StreamContext
     attr_accessor :stream, :tx, :send_window, :recv_window, :fragment, :content, :state
 
     # @param stream_id [Integer]
+    # @param send_initial_window_size [Integer]
+    # @param recv_initial_window_size [Integer]
     # @param proc [Proc]
-    def initialize(stream_id, proc)
+    def initialize(stream_id, send_initial_window_size, recv_initial_window_size, proc)
       @tx = Ractor::Port.new
       @stream = Stream.new(@tx, stream_id, proc)
-      @send_window = Window.new
-      @recv_window = Window.new
+      @send_window = Window.new(send_initial_window_size)
+      @recv_window = Window.new(recv_initial_window_size)
       @fragment = StringIO.new
       @content = StringIO.new
       @state = State.new

data/lib/biryani/utils.rb

@@ -0,0 +1,23 @@
+module Biryani
+  # @param obj [Object]
+  #
+  # @return [Boolean]
+  def self.err?(obj)
+    obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+  end
+
+  # @param obj [Object, ConnectionError, StreamError] frame or error
+  # @param last_stream_id [Integer]
+  #
+  # @return [Frame]
+  def self.unwrap(obj, last_stream_id)
+    case obj
+    when ConnectionError
+      obj.goaway(last_stream_id)
+    when StreamError
+      obj.rst_stream
+    else
+      obj
+    end
+  end
+end

data/lib/biryani/version.rb

@@ -1,3 +1,3 @@
 module Biryani
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.3'.freeze
 end

data/lib/biryani/window.rb

@@ -1,29 +1,34 @@
 module Biryani
   class Window
-    def initialize
-      @window = 2**16 - 1
-    end
+    attr_reader :length, :capacity
 
-    # @param length [Integer]
-    #
-    # @return [Boolean]
-    def available?(length)
-      @window > length
+    # @param initial_window_size [Integer]
+    def initialize(initial_window_size)
+      @length = initial_window_size
+      @capacity = initial_window_size
     end
 
     # @param length [Integer]
+    #
+    # @return [Integer]
     def consume!(length)
-      @window -= length
+      @length -= length
     end
 
     # @param length [Integer]
+    #
+    # @return [Integer]
     def increase!(length)
-      @window += length
+      @length += length
     end
 
+    # @param initial_window_size [Integer]
+    #
     # @return [Integer]
-    def length
-      @window
+    def update!(initial_window_size)
+      @length = initial_window_size - @capacity + @length
+      @capacity = initial_window_size
+      @length
     end
   end
 end

data/lib/biryani.rb

@@ -1,8 +1,8 @@
 require 'stringio'
 require 'uri'
 
-require_relative 'biryani/connection'
 require_relative 'biryani/connection_error'
+require_relative 'biryani/connection'
 require_relative 'biryani/data_buffer'
 require_relative 'biryani/frame'
 require_relative 'biryani/hpack'
@@ -10,8 +10,9 @@ require_relative 'biryani/http_request'
 require_relative 'biryani/http_response'
 require_relative 'biryani/server'
 require_relative 'biryani/state'
-require_relative 'biryani/streams_context'
 require_relative 'biryani/stream_error'
 require_relative 'biryani/stream'
+require_relative 'biryani/streams_context'
+require_relative 'biryani/utils'
 require_relative 'biryani/version'
 require_relative 'biryani/window'

data/spec/connection/handle_connection_window_update_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Connection do
       Frame::WindowUpdate.new(0, 1000)
     end
     let(:send_window) do
-      Window.new
+      Window.new(65_535)
     end
     it 'should handle' do
       expect { Connection.handle_connection_window_update(window_update, send_window) }.not_to raise_error

data/spec/connection/handle_data_spec.rb

@@ -0,0 +1,58 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_data' do
+    let(:decoder) do
+      HPACK::Decoder.new(4_096)
+    end
+
+    let(:recv_window1) do
+      Window.new(65_535)
+    end
+    let(:streams_ctx1) do
+      streams_ctx = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
+      streams_ctx
+    end
+    it 'should handle' do
+      expect(Connection.handle_data(2, 'Hello, world!', recv_window1, streams_ctx1, decoder)).to eq []
+      expect(streams_ctx1[2].content.string).to eq 'Hello, world!'
+    end
+
+    let(:recv_window2) do
+      recv_window = Window.new(65_535)
+      recv_window.consume!(65_535 / 2)
+      recv_window
+    end
+    let(:streams_ctx2) do
+      streams_ctx = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
+      streams_ctx[2].recv_window.consume!(65_535 / 2)
+      streams_ctx
+    end
+    it 'should handle' do
+      frames = Connection.handle_data(2, 'Hello, world!', recv_window2, streams_ctx2, decoder)
+      expect(frames.map(&:f_type)).to eq [FrameType::WINDOW_UPDATE, FrameType::WINDOW_UPDATE]
+      expect(frames.map(&:stream_id)).to eq [0, 2]
+      expect(frames.map(&:window_size_increment)).to eq [65_535 / 2 + 13, 65_535 / 2 + 13]
+      expect(streams_ctx2[2].content.string).to eq 'Hello, world!'
+    end
+
+    let(:recv_window3) do
+      recv_window = Window.new(65_535)
+      recv_window.consume!(65_535)
+      recv_window
+    end
+    let(:streams_ctx3) do
+      streams_ctx = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
+      streams_ctx
+    end
+    it 'should not handle' do
+      expect(Connection.handle_data(2, 'Hello, world!', recv_window3, streams_ctx3, decoder)).to be_kind_of ConnectionError
+    end
+  end
+end

data/spec/connection/handle_headers_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_headers' do
+    let(:headers) do
+      Frame::Headers.new(true, false, 2, nil, nil, 'this is dummy', nil)
+    end
+    let(:ctx) do
+      StreamContext.new(2, 65_535, 65_535, do_nothing_proc)
+    end
+    let(:decoder) do
+      HPACK::Decoder.new(4_096)
+    end
+    it 'should handle' do
+      expect(Connection.handle_headers(headers, ctx, decoder)).to eq nil
+      expect(ctx.fragment.string).to eq 'this is dummy'
+    end
+  end
+end

data/spec/connection/handle_rst_stream_spec.rb

@@ -5,17 +5,12 @@ RSpec.describe Connection do
     let(:rst_stream) do
       Frame::RstStream.new(2, 0)
     end
-    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
+    let(:ctx) do
+      StreamContext.new(2, 65_535, 65_535, do_nothing_proc)
     end
     it 'should handle' do
-      Connection.handle_rst_stream(rst_stream, streams_ctx)
-      expect(streams_ctx.length).to eq 2
-      expect(streams_ctx.count_active).to eq 0
-      expect(streams_ctx.closed_stream_ids.length).to eq 1
+      Connection.handle_rst_stream(rst_stream, ctx)
+      expect(ctx.closed?).to eq true
     end
   end
 end

data/spec/connection/handle_settings_spec.rb

@@ -8,12 +8,18 @@ RSpec.describe Connection do
     let(:decoder) do
       HPACK::Decoder.new(4_096)
     end
+    let(:streams_ctx) do
+      streams_ctx = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
+      streams_ctx
+    end
 
     let(:settings1) do
       Frame::Settings.new(false, 0, { SettingsID::SETTINGS_HEADER_TABLE_SIZE => 8_192 })
     end
     it 'should handle' do
-      reply_settings = Connection.handle_settings(settings1, send_settings, decoder)
+      reply_settings = Connection.handle_settings(settings1, send_settings, decoder, streams_ctx)
       expect(reply_settings.ack?).to eq true
       expect(reply_settings.setting.empty?).to eq true
       expect(send_settings[SettingsID::SETTINGS_MAX_CONCURRENT_STREAMS]).to eq 0xffffffff
@@ -25,7 +31,7 @@ RSpec.describe Connection do
       Frame::Settings.new(true, 0, {})
     end
     it 'should handle' do
-      expect(Connection.handle_settings(settings2, send_settings, decoder)).to eq nil
+      expect(Connection.handle_settings(settings2, send_settings, decoder, streams_ctx)).to eq nil
     end
   end
 end

data/spec/connection/handle_stream_window_update_spec.rb

@@ -6,15 +6,15 @@ RSpec.describe Connection do
       Frame::WindowUpdate.new(1, 1000)
     end
     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 = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
       streams_ctx
     end
     it 'should handle' do
       expect { Connection.handle_stream_window_update(window_update, streams_ctx) }.not_to raise_error
-      expect(streams_ctx[1].send_window.length).to eq 2**16 - 1 + 1000
-      expect(streams_ctx[2].send_window.length).to eq 2**16 - 1
+      expect(streams_ctx[1].send_window.length).to eq 65_535 + 1000
+      expect(streams_ctx[2].send_window.length).to eq 65_535
     end
   end
 end

data/spec/connection/send_spec.rb

@@ -10,29 +10,25 @@ RSpec.describe Connection do
     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!')
+      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy'.b, nil)
     end
     let(:send_window1) do
-      Window.new
+      Window.new(65_535)
     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 = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
       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
+      Connection.send_headers(io, 2, "\x88".b, false, 16_384, streams_ctx1)
+      Connection.send_data(io, 2, 'Hello, world!'.b, send_window1, 16_384, streams_ctx1, data_buffer)
+      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq "\x00\x00\x01\x01\x04\x00\x00\x00\x02\x88\x00\x00\x0d\x00\x01\x00\x00\x00\x02Hello, world!".b
+      expect(send_window1.length).to eq 65_535 - 13
+      expect(streams_ctx1[1].send_window.length).to eq 65_535
+      expect(streams_ctx1[2].send_window.length).to eq 65_535 - 13
       expect(data_buffer.length).to eq 0
     end
 
@@ -40,46 +36,43 @@ RSpec.describe Connection do
       Frame::Headers.new(true, true, 1, nil, nil, 'this is dummy', nil)
     end
     let(:send_window2) do
-      Window.new
+      Window.new(65_535)
     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 = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
       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
+      Connection.send_headers(io, 1, "\x88".b, true, 16_384, streams_ctx2)
+      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq "\x00\x00\x01\x01\x05\x00\x00\x00\x01\x88".b
+      expect(send_window2.length).to eq 65_535
+      expect(streams_ctx2[1].send_window.length).to eq 65_535
+      expect(streams_ctx2[2].send_window.length).to eq 65_535
       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
+      Window.new(65_535)
     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 = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
+      streams_ctx[2].send_window.consume!(65_535)
       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
+      Connection.send_data(io, 2, 'Hello, world!'.b, send_window3, 16_384, streams_ctx3, data_buffer)
+      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq ''.b
+      expect(send_window3.length).to eq 65_535
+      expect(streams_ctx3[1].send_window.length).to eq 65_535
       expect(streams_ctx3[2].send_window.length).to eq 0
       expect(data_buffer.length).to eq 1
     end
@@ -87,27 +80,24 @@ RSpec.describe Connection do
     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 = Window.new(65_535)
+      send_window.consume!(65_535)
       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 = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
       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 ''
+      Connection.send_data(io, 2, 'Hello, world!'.b, send_window4, 16_384, streams_ctx4, data_buffer)
+      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq ''.b
       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(streams_ctx4[1].send_window.length).to eq 65_535
+      expect(streams_ctx4[2].send_window.length).to eq 65_535
       expect(data_buffer.length).to eq 1
     end
   end

data/spec/connection/transition_state_send_spec.rb

@@ -3,9 +3,9 @@ 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 = StreamsContext.new(do_nothing_proc)
+      streams_ctx.new_context(1, 65_535, 65_535)
+      streams_ctx.new_context(2, 65_535, 65_535)
       streams_ctx
     end
 
@@ -21,7 +21,7 @@ RSpec.describe Connection do
     it 'should transition' do
       streams_ctx[1].state.transition!(headers, :recv)
       streams_ctx[2].state.transition!(headers, :recv)
-      Connection.close_all_streams(streams_ctx)
+      streams_ctx.close_all
       expect { streams_ctx[1].tx << nil }.to raise_error Ractor::ClosedError
       expect { streams_ctx[2].tx << nil }.to raise_error Ractor::ClosedError
     end