http-2 0.9.0 → 0.11.0

data/spec/connection_spec.rb

@@ -1,6 +1,7 @@
 require 'helper'
 
 RSpec.describe HTTP2::Connection do
+  include FrameHelpers
   before(:each) do
     @conn = Client.new
   end
@@ -8,18 +9,21 @@ RSpec.describe HTTP2::Connection do
   let(:f) { Framer.new }
 
   context 'initialization and settings' do
-    it 'should raise error if first frame is not SETTINGS' do
-      (FRAME_TYPES - [SETTINGS]).each do |frame|
-        frame = set_stream_id(f.generate(frame.deep_dup), 0x0)
-        expect { @conn.dup << frame }.to raise_error(ProtocolError)
+    it 'should raise error if first frame is not settings' do
+      (frame_types - [settings_frame]).each do |frame|
+        expect { @conn << frame }.to raise_error(ProtocolError)
+        expect(@conn).to be_closed
       end
+    end
 
-      expect { @conn << f.generate(SETTINGS.dup) }.to_not raise_error
+    it 'should not raise error if first frame is SETTINGS' do
+      expect { @conn << f.generate(settings_frame) }.to_not raise_error
       expect(@conn.state).to eq :connected
+      expect(@conn).to_not be_closed
     end
 
     it 'should raise error if SETTINGS stream != 0' do
-      frame = set_stream_id(f.generate(SETTINGS.dup), 0x1)
+      frame = set_stream_id(f.generate(settings_frame), 0x1)
       expect { @conn << frame }.to raise_error(ProtocolError)
     end
   end
@@ -38,7 +42,7 @@ RSpec.describe HTTP2::Connection do
 
     it 'should reflect incoming settings when SETTINGS is received' do
       expect(@conn.remote_settings[:settings_header_table_size]).to eq 4096
-      settings = SETTINGS.dup
+      settings = settings_frame
       settings[:payload] = [[:settings_header_table_size, 256]]
 
       @conn << f.generate(settings)
@@ -46,17 +50,39 @@ RSpec.describe HTTP2::Connection do
       expect(@conn.remote_settings[:settings_header_table_size]).to eq 256
     end
 
+    it 'should reflect settings_max_frame_size recevied from peer' do
+      settings = settings_frame
+      settings[:payload] = [[:settings_max_frame_size, 16_385]]
+
+      @conn << f.generate(settings)
+
+      frame = {
+        length: 16_385,
+        type: :data,
+        flags: [:end_stream],
+        stream: 1,
+        payload: 'a' * 16_385,
+      }
+      expect { @conn.send(frame) }.not_to raise_error(CompressionError)
+    end
+
     it 'should send SETTINGS ACK when SETTINGS is received' do
-      settings = SETTINGS.dup
+      settings = settings_frame
       settings[:payload] = [[:settings_header_table_size, 256]]
 
-      expect(@conn).to receive(:send) do |frame|
-        expect(frame[:type]).to eq :settings
-        expect(frame[:flags]).to eq [:ack]
-        expect(frame[:payload]).to eq []
+      # We should expect two frames here (append .twice) - one for the connection setup, and one for the settings ack.
+      frames = []
+      expect(@conn).to receive(:send).twice do |frame|
+        frames << frame
       end
 
+      @conn.send_connection_preface
       @conn << f.generate(settings)
+
+      frame = frames.last
+      expect(frame[:type]).to eq :settings
+      expect(frame[:flags]).to eq [:ack]
+      expect(frame[:payload]).to eq []
     end
   end
 
@@ -66,44 +92,47 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should change stream limit to received SETTINGS value' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       expect(@conn.remote_settings[:settings_max_concurrent_streams]).to eq 10
     end
 
     it 'should count open streams against stream limit' do
       s = @conn.new_stream
       expect(@conn.active_stream_count).to eq 0
-      s.receive HEADERS
+      s.receive headers_frame
       expect(@conn.active_stream_count).to eq 1
     end
 
     it 'should not count reserved streams against stream limit' do
       s1 = @conn.new_stream
-      s1.receive PUSH_PROMISE
+      s1.receive push_promise_frame
       expect(@conn.active_stream_count).to eq 0
 
       s2 = @conn.new_stream
-      s2.send PUSH_PROMISE.deep_dup
+      s2.send push_promise_frame
       expect(@conn.active_stream_count).to eq 0
 
       # transition to half closed
-      s1.receive HEADERS
-      s2.send HEADERS.deep_dup
+      s1.receive headers_frame
+      s2.send headers_frame
       expect(@conn.active_stream_count).to eq 2
 
       # transition to closed
-      s1.receive DATA
-      s2.send DATA.dup
+      s1.receive data_frame
+      s2.send data_frame
       expect(@conn.active_stream_count).to eq 0
+
+      expect(s1).to be_closed
+      expect(s2).to be_closed
     end
 
     it 'should not exceed stream limit set by peer' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
 
       expect do
         10.times do
           s = @conn.new_stream
-          s.send HEADERS.deep_dup
+          s.send headers_frame
         end
       end.to_not raise_error
 
@@ -111,9 +140,9 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should initialize stream with HEADERS priority value' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
 
-      stream, headers = nil, HEADERS.dup
+      stream, headers = nil, headers_frame
       headers[:weight] = 20
       headers[:stream_dependency] = 0
       headers[:exclusive] = false
@@ -125,16 +154,33 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should initialize idle stream on PRIORITY frame' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
 
       stream = nil
       @conn.on(:stream) { |s| stream = s }
-      @conn << f.generate(PRIORITY.dup)
+      @conn << f.generate(priority_frame)
 
       expect(stream.state).to eq :idle
     end
   end
 
+  context 'cleanup_recently_closed' do
+    it 'should cleanup old connections' do
+      now_ts = Time.now.to_i
+      stream_ids = Array.new(4) { @conn.new_stream.id }
+      expect(@conn.instance_variable_get('@streams').size).to eq(4)
+
+      # Assume that the first 3 streams were closed in different time
+      recently_closed = stream_ids[0, 3].zip([now_ts - 100, now_ts - 50, now_ts - 5]).to_h
+      @conn.instance_variable_set('@streams_recently_closed', recently_closed)
+
+      # Cleanup should delete streams that were closed earlier than 15s ago
+      @conn.__send__(:cleanup_recently_closed)
+      expect(@conn.instance_variable_get('@streams').size).to eq(2)
+      expect(@conn.instance_variable_get('@streams_recently_closed')).to eq(stream_ids[2] => now_ts - 5)
+    end
+  end
+
   context 'Headers pre/post processing' do
     it 'should not concatenate multiple occurences of a header field with the same name' do
       input = [
@@ -161,16 +207,14 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should not split zero-concatenated header field values' do
-      input = [
-        ['cache-control', "max-age=60, private\0must-revalidate"],
-        ['content-type', 'text/html'],
-        ['cookie', "a=b\0c=d; e=f"],
-      ]
-      expected = [
-        ['cache-control', "max-age=60, private\0must-revalidate"],
-        ['content-type', 'text/html'],
-        ['cookie', "a=b\0c=d; e=f"],
-      ]
+      input = [*RESPONSE_HEADERS,
+               ['cache-control', "max-age=60, private\0must-revalidate"],
+               ['content-type', 'text/html'],
+               ['cookie', "a=b\0c=d; e=f"]]
+      expected = [*RESPONSE_HEADERS,
+                  ['cache-control', "max-age=60, private\0must-revalidate"],
+                  ['content-type', 'text/html'],
+                  ['cookie', "a=b\0c=d; e=f"]]
 
       result = nil
       @conn.on(:stream) do |stream|
@@ -192,13 +236,13 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should update connection and stream windows on SETTINGS' do
-      settings, data = SETTINGS.dup, DATA.dup
+      settings, data = settings_frame, data_frame
       settings[:payload] = [[:settings_initial_window_size, 1024]]
       data[:payload] = 'x' * 2048
 
       stream = @conn.new_stream
 
-      stream.send HEADERS.deep_dup
+      stream.send headers_frame
       stream.send data
       expect(stream.remote_window).to eq(DEFAULT_FLOW_WINDOW - 2048)
       expect(@conn.remote_window).to eq(DEFAULT_FLOW_WINDOW - 2048)
@@ -209,7 +253,7 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should initialize streams with window specified by peer' do
-      settings = SETTINGS.dup
+      settings = settings_frame
       settings[:payload] = [[:settings_initial_window_size, 1024]]
 
       @conn << f.generate(settings)
@@ -217,37 +261,37 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should observe connection flow control' do
-      settings, data = SETTINGS.dup, DATA.dup
+      settings, data = settings_frame, data_frame
       settings[:payload] = [[:settings_initial_window_size, 1000]]
 
       @conn << f.generate(settings)
       s1 = @conn.new_stream
       s2 = @conn.new_stream
 
-      s1.send HEADERS.deep_dup
+      s1.send headers_frame
       s1.send data.merge(payload: 'x' * 900)
       expect(@conn.remote_window).to eq 100
 
-      s2.send HEADERS.deep_dup
+      s2.send headers_frame
       s2.send data.merge(payload: 'x' * 200)
       expect(@conn.remote_window).to eq 0
       expect(@conn.buffered_amount).to eq 100
 
-      @conn << f.generate(WINDOW_UPDATE.merge(stream: 0, increment: 1000))
+      @conn << f.generate(window_update_frame.merge(stream: 0, increment: 1000))
       expect(@conn.buffered_amount).to eq 0
       expect(@conn.remote_window).to eq 900
     end
 
     it 'should update window when data received is over half of the maximum local window size' do
-      settings, data = SETTINGS.dup, DATA.dup
+      settings, data = settings_frame, data_frame
       conn = Client.new(settings_initial_window_size: 500)
 
       conn.receive f.generate(settings)
       s1 = conn.new_stream
       s2 = conn.new_stream
 
-      s1.send HEADERS.deep_dup
-      s2.send HEADERS.deep_dup
+      s1.send headers_frame
+      s2.send headers_frame
       expect(conn).to receive(:send) do |frame|
         expect(frame[:type]).to eq :window_update
         expect(frame[:stream]).to eq 0
@@ -263,11 +307,11 @@ RSpec.describe HTTP2::Connection do
 
   context 'framing' do
     it 'should buffer incomplete frames' do
-      settings = SETTINGS.dup
+      settings = settings_frame
       settings[:payload] = [[:settings_initial_window_size, 1000]]
       @conn << f.generate(settings)
 
-      frame = f.generate(WINDOW_UPDATE.merge(stream: 0, increment: 1000))
+      frame = f.generate(window_update_frame.merge(stream: 0, increment: 1000))
       @conn << frame
       expect(@conn.remote_window).to eq 2000
 
@@ -283,10 +327,10 @@ RSpec.describe HTTP2::Connection do
       ]
 
       cc = Compressor.new
-      headers = HEADERS.dup
+      headers = headers_frame
       headers[:payload] = cc.encode(req_headers)
 
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       @conn.on(:stream) do |stream|
         expect(stream).to receive(:<<) do |frame|
           expect(frame[:payload]).to eq req_headers
@@ -303,7 +347,7 @@ RSpec.describe HTTP2::Connection do
       ]
 
       cc = Compressor.new
-      h1, h2 = HEADERS.dup, CONTINUATION.dup
+      h1, h2 = headers_frame, continuation_frame
 
       # Header block fragment might not complete for decompression
       payload = cc.encode(req_headers)
@@ -314,7 +358,7 @@ RSpec.describe HTTP2::Connection do
       h2[:payload] = payload # the remaining
       h2[:stream] = 5
 
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       @conn.on(:stream) do |stream|
         expect(stream).to receive(:<<) do |frame|
           expect(frame[:payload]).to eq req_headers
@@ -326,28 +370,28 @@ RSpec.describe HTTP2::Connection do
     end
 
     it 'should require that split header blocks are a contiguous sequence' do
-      headers = HEADERS.dup
+      headers = headers_frame
       headers[:flags] = []
 
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       @conn << f.generate(headers)
-      (FRAME_TYPES - [CONTINUATION]).each do |frame|
+      (frame_types - [continuation_frame]).each do |frame|
         expect { @conn << f.generate(frame.deep_dup) }.to raise_error(ProtocolError)
       end
     end
 
     it 'should raise compression error on encode of invalid frame' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       stream = @conn.new_stream
 
       expect do
-        stream.headers('name' => Float::INFINITY)
+        stream.headers({ 'name' => Float::INFINITY })
       end.to raise_error(CompressionError)
     end
 
     it 'should raise connection error on decode of invalid frame' do
-      @conn << f.generate(SETTINGS.dup)
-      frame = f.generate(DATA.dup) # Receiving DATA on unopened stream 1 is an error.
+      @conn << f.generate(settings_frame)
+      frame = f.generate(data_frame) # Receiving DATA on unopened stream 1 is an error.
       # Connection errors emit protocol error frames
       expect { @conn << frame }.to raise_error(ProtocolError)
     end
@@ -358,7 +402,7 @@ RSpec.describe HTTP2::Connection do
       @conn.settings(settings_max_concurrent_streams: 10,
                      settings_initial_window_size: 0x7fffffff)
 
-      expect(bytes).to eq f.generate(SETTINGS.dup)
+      expect(bytes).to eq f.generate(settings_frame)
     end
 
     it 'should compress stream headers' do
@@ -369,10 +413,10 @@ RSpec.describe HTTP2::Connection do
       end
 
       stream = @conn.new_stream
-      stream.headers(':method' => 'get',
-                     ':scheme' => 'http',
-                     ':authority' => 'www.example.org',
-                     ':path'   => '/resource')
+      stream.headers({ ':method' => 'get',
+                       ':scheme' => 'http',
+                       ':authority' => 'www.example.org',
+                       ':path'   => '/resource' })
     end
 
     it 'should generate CONTINUATION if HEADERS is too long' do
@@ -470,79 +514,106 @@ RSpec.describe HTTP2::Connection do
   context 'connection management' do
     it 'should raise error on invalid connection header' do
       srv = Server.new
-      expect { srv << f.generate(SETTINGS.dup) }.to raise_error(HandshakeError)
+      expect { srv << f.generate(settings_frame) }.to raise_error(HandshakeError)
 
       srv = Server.new
       expect do
         srv << CONNECTION_PREFACE_MAGIC
-        srv << f.generate(SETTINGS.dup)
+        srv << f.generate(settings_frame)
       end.to_not raise_error
     end
 
     it 'should respond to PING frames' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       expect(@conn).to receive(:send) do |frame|
         expect(frame[:type]).to eq :ping
         expect(frame[:flags]).to eq [:ack]
         expect(frame[:payload]).to eq '12345678'
       end
 
-      @conn << f.generate(PING.dup)
+      @conn << f.generate(ping_frame)
     end
 
     it 'should fire callback on PONG' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
 
       pong = nil
       @conn.ping('12345678') { |d| pong = d }
-      @conn << f.generate(PONG.dup)
+      @conn << f.generate(pong_frame)
       expect(pong).to eq '12345678'
     end
 
     it 'should fire callback on receipt of GOAWAY' do
       last_stream, payload, error = nil
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
       @conn.on(:goaway) do |s, e, p|
         last_stream = s
         error = e
         payload = p
       end
-      @conn << f.generate(GOAWAY.merge(last_stream: 17, payload: 'test'))
+      @conn << f.generate(goaway_frame.merge(last_stream: 17, payload: 'test'))
 
       expect(last_stream).to eq 17
       expect(error).to eq :no_error
       expect(payload).to eq 'test'
+
+      expect(@conn).to be_closed
     end
 
     it 'should raise error when opening new stream after sending GOAWAY' do
       @conn.goaway
+      expect(@conn).to be_closed
+
       expect { @conn.new_stream }.to raise_error(ConnectionClosed)
     end
 
     it 'should raise error when opening new stream after receiving GOAWAY' do
-      @conn << f.generate(SETTINGS.dup)
-      @conn << f.generate(GOAWAY.dup)
+      @conn << f.generate(settings_frame)
+      @conn << f.generate(goaway_frame)
       expect { @conn.new_stream }.to raise_error(ConnectionClosed)
     end
 
+    it 'should not raise error when receiving connection management frames immediately after emitting goaway' do
+      @conn.goaway
+      expect(@conn).to be_closed
+
+      expect { @conn << f.generate(settings_frame) }.not_to raise_error(ProtocolError)
+      expect { @conn << f.generate(ping_frame) }.not_to raise_error(ProtocolError)
+      expect { @conn << f.generate(goaway_frame) }.not_to raise_error(ProtocolError)
+    end
+
     it 'should process connection management frames after GOAWAY' do
-      @conn << f.generate(SETTINGS.dup)
-      @conn << f.generate(HEADERS.dup)
-      @conn << f.generate(GOAWAY.dup)
-      @conn << f.generate(HEADERS.merge(stream: 7))
-      @conn << f.generate(PUSH_PROMISE.dup)
+      @conn << f.generate(settings_frame)
+      @conn << f.generate(headers_frame)
+      @conn << f.generate(goaway_frame)
+      @conn << f.generate(headers_frame.merge(stream: 7))
+      @conn << f.generate(push_promise_frame)
 
       expect(@conn.active_stream_count).to eq 1
     end
 
     it 'should raise error on frame for invalid stream ID' do
-      @conn << f.generate(SETTINGS.dup)
+      @conn << f.generate(settings_frame)
 
       expect do
-        @conn << f.generate(DATA.dup.merge(stream: 31))
+        @conn << f.generate(data_frame.merge(stream: 31))
       end.to raise_error(ProtocolError)
     end
 
+    it 'should not raise an error on frame for a closed stream ID' do
+      srv = Server.new
+      srv << CONNECTION_PREFACE_MAGIC
+
+      stream = srv.new_stream
+      stream.send headers_frame
+      stream.send data_frame
+      stream.close
+
+      expect do
+        srv << f.generate(rst_stream_frame.merge(stream: stream.id))
+      end.to_not raise_error
+    end
+
     it 'should send GOAWAY frame on connection error' do
       stream = @conn.new_stream
 
@@ -557,7 +628,7 @@ RSpec.describe HTTP2::Connection do
         [frame]
       end
 
-      expect { @conn << f.generate(DATA.dup) }.to raise_error(ProtocolError)
+      expect { @conn << f.generate(data_frame) }.to raise_error(ProtocolError)
     end
   end
 
@@ -586,8 +657,8 @@ RSpec.describe HTTP2::Connection do
     end
 
     it '.goaway should generate GOAWAY frame with last processed stream ID' do
-      @conn << f.generate(SETTINGS.dup)
-      @conn << f.generate(HEADERS.merge(stream: 17))
+      @conn << f.generate(settings_frame)
+      @conn << f.generate(headers_frame.merge(stream: 17))
 
       expect(@conn).to receive(:send) do |frame|
         expect(frame[:type]).to eq :goaway