http-2 0.8.4 → 0.10.2

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = '0.8.4'.freeze
+  VERSION = '0.10.2'.freeze
 end

data/spec/client_spec.rb

@@ -1,6 +1,7 @@
 require 'helper'
 
 RSpec.describe HTTP2::Client do
+  include FrameHelpers
   before(:each) do
     @client = Client.new
   end
@@ -32,6 +33,35 @@ RSpec.describe HTTP2::Client do
       expect(frame[:type]).to eq :settings
       expect(frame[:payload]).to include([:settings_max_concurrent_streams, 200])
     end
+
+    it 'should initialize client when receiving server settings before sending ack' do
+      frames = []
+      @client.on(:frame) { |bytes| frames << bytes }
+      @client << f.generate(settings_frame)
+
+      expect(frames[0]).to eq CONNECTION_PREFACE_MAGIC
+      expect(f.parse(frames[1])[:type]).to eq :settings
+      ack_frame = f.parse(frames[2])
+      expect(ack_frame[:type]).to eq :settings
+      expect(ack_frame[:flags]).to include(:ack)
+    end
+  end
+
+  context 'upgrade' do
+    it 'fails when client has already created streams' do
+      @client.new_stream
+      expect { @client.upgrade }.to raise_error(HTTP2::Error::ProtocolError)
+    end
+
+    it 'sends the preface' do
+      expect(@client).to receive(:send_connection_preface)
+      @client.upgrade
+    end
+
+    it 'initializes the first stream in the half-closed state' do
+      stream = @client.upgrade
+      expect(stream.state).to be(:half_closed_local)
+    end
   end
 
   context 'push' do
@@ -43,41 +73,57 @@ RSpec.describe HTTP2::Client do
 
     it 'should raise error on PUSH_PROMISE against stream 0' do
       expect do
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 0)
+        @client << set_stream_id(f.generate(push_promise_frame), 0)
       end.to raise_error(ProtocolError)
     end
 
     it 'should raise error on PUSH_PROMISE against bogus stream' do
       expect do
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 31_415)
+        @client << set_stream_id(f.generate(push_promise_frame), 31_415)
       end.to raise_error(ProtocolError)
     end
 
     it 'should raise error on PUSH_PROMISE against non-idle stream' do
       expect do
         s = @client.new_stream
-        s.send HEADERS.dup
+        s.send headers_frame
 
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+        @client << set_stream_id(f.generate(push_promise_frame), s.id)
+        @client << set_stream_id(f.generate(push_promise_frame), s.id)
       end.to raise_error(ProtocolError)
     end
 
     it 'should emit stream object for received PUSH_PROMISE' do
       s = @client.new_stream
-      s.send HEADERS.deep_dup
+      s.send headers_frame
 
       promise = nil
       @client.on(:promise) { |stream| promise = stream }
-      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
 
       expect(promise.id).to eq 2
       expect(promise.state).to eq :reserved_remote
     end
 
+    it 'should emit promise headers for received PUSH_PROMISE' do
+      header = nil
+      s = @client.new_stream
+      s.send headers_frame
+
+      @client.on(:promise) do |stream|
+        stream.on(:promise_headers) do |h|
+          header = h
+        end
+      end
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
+
+      expect(header).to be_a(Array)
+      # expect(header).to eq([%w(a b)])
+    end
+
     it 'should auto RST_STREAM promises against locally-RST stream' do
       s = @client.new_stream
-      s.send HEADERS.deep_dup
+      s.send headers_frame
       s.close
 
       allow(@client).to receive(:send)
@@ -86,7 +132,57 @@ RSpec.describe HTTP2::Client do
         expect(frame[:stream]).to eq 2
       end
 
-      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
+    end
+  end
+
+  context 'alt-svc' do
+    context 'received in the connection' do
+      it 'should emit :altsvc when receiving one' do
+        @client << f.generate(settings_frame)
+        frame = nil
+        @client.on(:altsvc) do |f|
+          frame = f
+        end
+        @client << f.generate(altsvc_frame)
+        expect(frame).to be_a(Hash)
+      end
+      it 'should not emit :altsvc when the frame when contains no host' do
+        @client << f.generate(settings_frame)
+        frame = nil
+        @client.on(:altsvc) do |f|
+          frame = f
+        end
+
+        @client << f.generate(altsvc_frame.merge(origin: nil))
+        expect(frame).to be_nil
+      end
+    end
+    context 'received in a stream' do
+      it 'should emit :altsvc' do
+        s = @client.new_stream
+        s.send headers_frame
+        s.close
+
+        frame = nil
+        s.on(:altsvc) { |f| frame = f }
+
+        @client << set_stream_id(f.generate(altsvc_frame.merge(origin: nil)), s.id)
+
+        expect(frame).to be_a(Hash)
+      end
+      it 'should not emit :alt_svc when the frame when contains a origin' do
+        s = @client.new_stream
+        s.send headers_frame
+        s.close
+
+        frame = nil
+        s.on(:altsvc) { |f| frame = f }
+
+        @client << set_stream_id(f.generate(altsvc_frame), s.id)
+
+        expect(frame).to be_nil
+      end
     end
   end
 end

data/spec/compressor_spec.rb

@@ -236,6 +236,24 @@ RSpec.describe HTTP2::Header do
         expect(cc.table.size).to be 1
         expect(cc.table.first[0]).to eq 'test2'
       end
+
+      it 'should reject table size update if exceed limit' do
+        cc = EncodingContext.new(table_size: 4096)
+
+        expect { cc.process(type: :changetablesize, value: 150_000_000) }.to raise_error(CompressionError)
+      end
+    end
+
+    context 'encode' do
+      it 'downcases the field' do
+        expect(EncodingContext.new.encode([['Content-Length', '5']]))
+          .to eq(EncodingContext.new.encode([['content-length', '5']]))
+      end
+
+      it 'fills :path if empty' do
+        expect(EncodingContext.new.encode([[':path', '']]))
+          .to eq(EncodingContext.new.encode([[':path', '/']]))
+      end
     end
   end
 
@@ -339,6 +357,78 @@ RSpec.describe HTTP2::Header do
         },
       ],
     },
+    { title: 'D.4.a.  Request Examples with Huffman - Client Handling of Improperly Ordered Headers',
+      type: :request,
+      table_size: 4096,
+      huffman: :always,
+      streams: [
+        { wire: '8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 57,
+        },
+        { wire: '8286 84be 5886 a8eb 1064 9cbf',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            ['cache-control', 'no-cache'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 110,
+        },
+        { wire: "8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925
+                 a849 e95b b8e8 b4bf",
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'https'],
+            ['custom-key', 'custom-value'],
+            [':path', '/index.html'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            ['custom-key', 'custom-value'],
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 164,
+        },
+      ],
+    },
+    { title: 'D.4.b.  Request Examples with Huffman - Server Handling of Improperly Ordered Headers',
+      type: :request,
+      bypass_encoder: true,
+      table_size: 4096,
+      huffman: :always,
+      streams: [
+        { wire: '8286408825a849e95ba97d7f8925a849e95bb8e8b4bf84418cf1e3c2e5f23a6ba0ab90f4ff',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            ['custom-key', 'custom-value'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            ['custom-key', 'custom-value'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 111,
+          has_bad_headers: true,
+        },
+      ],
+    },
     { title: 'D.5.  Response Examples without Huffman',
       type: :response,
       table_size: 256,
@@ -462,6 +552,22 @@ RSpec.describe HTTP2::Header do
         },
       ],
     },
+    { title: 'D.6.a.  Response Examples with Huffman - dynamic table size updates should not trigger exceptions',
+      type: :response,
+      table_size: 4096,
+      huffman: :always,
+      bypass_encoder: true,
+      streams: [
+        { wire: '2088 7689 aa63 55e5 80ae 16d7 17',
+          emitted: [
+            [':status', '200'],
+            ['server', 'nginx/1.15.2'],
+          ],
+          table: [],
+          table_size: 0,
+        },
+      ],
+    },
   ]
 
   context 'decode' do
@@ -473,25 +579,38 @@ RSpec.describe HTTP2::Header do
             before do
               (0...nth).each do |i|
                 bytes = [ex[:streams][i][:wire].delete(" \n")].pack('H*')
-                @dc.decode(HTTP2::Buffer.new(bytes))
+                if ex[:streams][i][:has_bad_headers]
+                  expect { @dc.decode(HTTP2::Buffer.new(bytes)) }.to raise_error ProtocolError
+                else
+                  @dc.decode(HTTP2::Buffer.new(bytes))
+                end
               end
             end
-            subject do
-              bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
-              @emitted = @dc.decode(HTTP2::Buffer.new(bytes))
-            end
-            it 'should emit expected headers' do
-              subject
-              # order-perserving compare
-              expect(@emitted).to eq ex[:streams][nth][:emitted]
-            end
-            it 'should update header table' do
-              subject
-              expect(@dc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
-            end
-            it 'should compute header table size' do
-              subject
-              expect(@dc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+            if ex[:streams][nth][:has_bad_headers]
+              it 'should raise CompressionError' do
+                bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
+                expect { @dc.decode(HTTP2::Buffer.new(bytes)) }.to raise_error ProtocolError
+              end
+            else
+              subject do
+                bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
+                @emitted = @dc.decode(HTTP2::Buffer.new(bytes))
+              end
+              it 'should emit expected headers' do
+                subject
+                # partitioned compare
+                pseudo_headers, headers = ex[:streams][nth][:emitted].partition { |f, _| f.start_with? ':' }
+                partitioned_headers = pseudo_headers + headers
+                expect(@emitted).to eq partitioned_headers
+              end
+              it 'should update header table' do
+                subject
+                expect(@dc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
+              end
+              it 'should compute header table size' do
+                subject
+                expect(@dc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+              end
             end
           end
         end
@@ -501,6 +620,7 @@ RSpec.describe HTTP2::Header do
 
   context 'encode' do
     spec_examples.each do |ex|
+      next if ex[:bypass_encoder]
       context "spec example #{ex[:title]}" do
         ex[:streams].size.times do |nth|
           context "request #{nth + 1}" do
@@ -510,22 +630,33 @@ RSpec.describe HTTP2::Header do
             end
             before do
               (0...nth).each do |i|
-                @cc.encode(ex[:streams][i][:emitted])
+                if ex[:streams][i][:has_bad_headers]
+                  @cc.encode(ex[:streams][i][:emitted], ensure_proper_ordering: false)
+                else
+                  @cc.encode(ex[:streams][i][:emitted])
+                end
               end
             end
             subject do
-              @cc.encode(ex[:streams][nth][:emitted])
+              if ex[:streams][nth][:has_bad_headers]
+                @cc.encode(ex[:streams][nth][:emitted], ensure_proper_ordering: false)
+              else
+                @cc.encode(ex[:streams][nth][:emitted])
+              end
             end
             it 'should emit expected bytes on wire' do
+              puts subject.unpack('H*').first
               expect(subject.unpack('H*').first).to eq ex[:streams][nth][:wire].delete(" \n")
             end
-            it 'should update header table' do
-              subject
-              expect(@cc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
-            end
-            it 'should compute header table size' do
-              subject
-              expect(@cc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+            unless ex[:streams][nth][:has_bad_headers]
+              it 'should update header table' do
+                subject
+                expect(@cc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
+              end
+              it 'should compute header table size' do
+                subject
+                expect(@cc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+              end
             end
           end
         end

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)
@@ -47,16 +51,22 @@ RSpec.describe HTTP2::Connection do
     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 +76,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 +124,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 +138,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 +191,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 +220,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 +237,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,35 +245,57 @@ 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_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_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
+        expect(frame[:increment]).to eq 400
+      end
+      conn.receive f.generate(data.merge(payload: 'x' * 200, end_stream: false, stream: s1.id))
+      conn.receive f.generate(data.merge(payload: 'x' * 200, end_stream: false, stream: s2.id))
+      expect(s1.local_window).to eq 300
+      expect(s2.local_window).to eq 300
+      expect(conn.local_window).to eq 500
+    end
   end
 
   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
 
@@ -261,10 +311,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
@@ -281,7 +331,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)
@@ -292,7 +342,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
@@ -304,18 +354,18 @@ 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
@@ -324,8 +374,8 @@ RSpec.describe HTTP2::Connection do
     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
@@ -336,7 +386,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
@@ -448,79 +498,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
 
@@ -535,7 +612,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
 
@@ -564,8 +641,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