http-2 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f52820ad290d538c293b8d008baa622bc788c07c
-  data.tar.gz: 93aa6df1ade7720059e84c8ffd69d1fb2385028d
+SHA256:
+  metadata.gz: 5617138c0740b55546b79e29a06978a9fcb9aae208ccb2f695c32939eca5f88a
+  data.tar.gz: 193880583c0a80aa569f433977af1798c98be25a86fb782a410e16eb38d5116c
 SHA512:
-  metadata.gz: d8fb28dd5124a1dc9995f250ca82a0a257d5a1c2a4b802fadcf0d7fe30a054c1e1e312fa81f6bb69888103783d23916c3bdb464c5eb5819e2ef68609ddeae303
-  data.tar.gz: 82f8859ce4752d46be361deb76e1b37b076472b0b07262ca5aa9d7b2daa2c50d6d28b44aa8811031b58a294424c1e8fc056f22ffd9c92301a48b2369503784ae
+  metadata.gz: 46fde2633ab7d074136a32e7ae8cdf90ecd037f3a95bfeabab9557d72a13487a47a3e298339bc74df4d89c6b802537b9c35a1f7709fd6cf1f4fde44eecbe468e
+  data.tar.gz: 6eadeb79f3bbf6fa1911933e2dc399bfe50ae08c598cb72278a37e0c42102bf27ccbed77b7acb5e7f1e85a55bd6967e63a8950fa3184fb7c9eef750c8a9e123c

data/.rubocop.yml

@@ -11,6 +11,7 @@ AllCops:
 Layout/IndentHeredoc:
   Exclude:
     - 'lib/tasks/generate_huffman_table.rb'
+    - 'example/*'
 
 Metrics/LineLength:
   Max: 120

data/.rubocop_todo.yml

@@ -19,6 +19,9 @@ Metrics/BlockNesting:
 Metrics/ClassLength:
   Max: 325
 
+Metrics/ModuleLength:
+  Max: 120
+
 # Offense count: 12
 Metrics/CyclomaticComplexity:
   Max: 60
@@ -59,6 +62,15 @@ Style/Documentation:
     - 'example/upgrade_server.rb'
     - 'lib/tasks/generate_huffman_table.rb'
 
+# Offense count: 3
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: braces, no_braces, context_dependent
+Style/BracesAroundHashParameters:
+  Exclude:
+    - 'spec/connection_spec.rb'
+    - 'spec/server_spec.rb'
+
 # Offense count: 1
 # Cop supports --auto-correct.
 Style/EmptyCaseCondition:

data/.travis.yml

@@ -1,10 +1,13 @@
-sudo: false
 language: ruby
+cache: bundler
 rvm:
   - 2.1
   - 2.2
-  - 2.3.0
-  - 2.4.0
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
   - jruby-9.2.0.0 # latest stable
   - jruby-head
   - rbx-2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Ilya Grigorik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/example/upgrade_client.rb

@@ -34,16 +34,16 @@ end
 
 # upgrader module
 class UpgradeHandler
-  UPGRADE_REQUEST = <<-RESP.strip_heredoc.freeze
-    GET %s HTTP/1.1
-    Connection: Upgrade, HTTP2-Settings
-    HTTP2-Settings: #{HTTP2::Client.settings_header(settings_max_concurrent_streams: 100)}
-    Upgrade: h2c
-    Host: %s
-    User-Agent: http-2 upgrade
-    Accept: */*
-
-  RESP
+  UPGRADE_REQUEST = <<RESP.freeze
+GET %s HTTP/1.1
+Connection: Upgrade, HTTP2-Settings
+HTTP2-Settings: #{HTTP2::Client.settings_header(settings_max_concurrent_streams: 100)}
+Upgrade: h2c
+Host: %s
+User-Agent: http-2 upgrade
+Accept: */*
+
+RESP
 
   attr_reader :complete, :parsing
   def initialize(conn, sock)

data/example/upgrade_server.rb

@@ -39,12 +39,12 @@ end
 
 class UpgradeHandler
   VALID_UPGRADE_METHODS = %w(GET OPTIONS).freeze
-  UPGRADE_RESPONSE = <<-RESP.strip_heredoc.freeze
-    HTTP/1.1 101 Switching Protocols
-    Connection: Upgrade
-    Upgrade: h2c
+  UPGRADE_RESPONSE = <<RESP.freeze
+HTTP/1.1 101 Switching Protocols
+Connection: Upgrade
+Upgrade: h2c
 
-  RESP
+RESP
 
   attr_reader :complete, :headers, :body, :parsing
 

data/http-2.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler'
 end

data/lib/http/2/compressor.rb

@@ -146,6 +146,9 @@ module HTTP2
 
         case cmd[:type]
         when :changetablesize
+          if cmd[:value] > @limit
+            fail CompressionError, 'dynamic table size update exceed limit'
+          end
           self.table_size = cmd[:value]
 
         when :indexed
@@ -328,7 +331,7 @@ module HTTP2
     class Compressor
       # @param options [Hash] encoding options
       def initialize(**options)
-        @cc = EncodingContext.new(options)
+        @cc = EncodingContext.new(**options)
       end
 
       # Set dynamic table size in EncodingContext
@@ -467,7 +470,7 @@ module HTTP2
     class Decompressor
       # @param options [Hash] decoding options.  Only :table_size is effective.
       def initialize(**options)
-        @cc = EncodingContext.new(options)
+        @cc = EncodingContext.new(**options)
       end
 
       # Set dynamic table size in EncodingContext

data/lib/http/2/connection.rb

@@ -33,6 +33,9 @@ module HTTP2
   # Default connection "fast-fail" preamble string as defined by the spec.
   CONNECTION_PREFACE_MAGIC = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".freeze
 
+  # Time to hold recently closed streams until purge (seconds)
+  RECENTLY_CLOSED_STREAMS_TTL = 15
+
   # Connection encapsulates all of the connection, stream, flow-control,
   # error management, and other processing logic required for a well-behaved
   # HTTP 2.0 endpoint.
@@ -73,8 +76,8 @@ module HTTP2
       @local_settings  = DEFAULT_CONNECTION_SETTINGS.merge(settings)
       @remote_settings = SPEC_DEFAULT_CONNECTION_SETTINGS.dup
 
-      @compressor   = Header::Compressor.new(settings)
-      @decompressor = Header::Decompressor.new(settings)
+      @compressor   = Header::Compressor.new(**settings)
+      @decompressor = Header::Decompressor.new(**settings)
 
       @active_stream_count = 0
       @streams = {}
@@ -536,7 +539,7 @@ module HTTP2
         # Process pending settings we have sent.
         [@pending_settings.shift, :local]
       else
-        connection_error(check) if validate_settings(@remote_role, frame[:payload])
+        connection_error if validate_settings(@remote_role, frame[:payload])
         [frame[:payload], :remote]
       end
 
@@ -590,7 +593,8 @@ module HTTP2
           # nothing to do
 
         when :settings_max_frame_size
-          # nothing to do
+          # update framer max_frame_size
+          @framer.max_frame_size = v
 
           # else # ignore unknown settings
         end
@@ -671,7 +675,7 @@ module HTTP2
     def activate_stream(id: nil, **args)
       connection_error(msg: 'Stream ID already exists') if @streams.key?(id)
 
-      stream = Stream.new({ connection: self, id: id }.merge(args))
+      stream = Stream.new(**{ connection: self, id: id }.merge(args))
 
       # Streams that are in the "open" state, or either of the "half closed"
       # states count toward the maximum number of streams that an endpoint is
@@ -683,13 +687,9 @@ module HTTP2
         # Store a reference to the closed stream, such that we can respond
         # to any in-flight frames while close is registered on both sides.
         # References to such streams will be purged whenever another stream
-        # is closed, with a minimum of 15s RTT time window.
-        @streams_recently_closed[id] = Time.now
-        to_delete = @streams_recently_closed.select { |_, v| (Time.now - v) > 15 }
-        to_delete.each do |stream_id|
-          @streams.delete stream_id
-          @streams_recently_closed.delete stream_id
-        end
+        # is closed, with a defined RTT time window.
+        @streams_recently_closed[id] = Time.now.to_i
+        cleanup_recently_closed
       end
 
       stream.on(:promise, &method(:promise)) if self.is_a? Server
@@ -698,6 +698,22 @@ module HTTP2
       @streams[id] = stream
     end
 
+    # Purge recently streams closed within defined RTT time window.
+    def cleanup_recently_closed
+      now_ts = Time.now.to_i
+      to_delete = []
+      @streams_recently_closed.each do |stream_id, ts|
+        # Ruby Hash enumeration is ordered, so once fresh stream is met we can stop searching.
+        break if now_ts - ts < RECENTLY_CLOSED_STREAMS_TTL
+        to_delete << stream_id
+      end
+
+      to_delete.each do |stream_id|
+        @streams.delete stream_id
+        @streams_recently_closed.delete stream_id
+      end
+    end
+
     # Emit GOAWAY error indicating to peer that the connection is being
     # aborted, and once sent, raise a local exception.
     #

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = '0.10.1'.freeze
+  VERSION = '0.11.0'.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
@@ -36,7 +37,7 @@ RSpec.describe HTTP2::Client do
     it 'should initialize client when receiving server settings before sending ack' do
       frames = []
       @client.on(:frame) { |bytes| frames << bytes }
-      @client << f.generate(SETTINGS.dup)
+      @client << f.generate(settings_frame)
 
       expect(frames[0]).to eq CONNECTION_PREFACE_MAGIC
       expect(f.parse(frames[1])[:type]).to eq :settings
@@ -72,33 +73,33 @@ 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.deep_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
@@ -107,14 +108,14 @@ RSpec.describe HTTP2::Client do
     it 'should emit promise headers for received PUSH_PROMISE' do
       header = nil
       s = @client.new_stream
-      s.send HEADERS.deep_dup
+      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.deep_dup), s.id)
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
 
       expect(header).to be_a(Array)
       # expect(header).to eq([%w(a b)])
@@ -122,7 +123,7 @@ RSpec.describe HTTP2::Client do
 
     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)
@@ -131,54 +132,54 @@ 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.dup)
+        @client << f.generate(settings_frame)
         frame = nil
         @client.on(:altsvc) do |f|
           frame = f
         end
-        @client << f.generate(ALTSVC.deep_dup)
+        @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.dup)
+        @client << f.generate(settings_frame)
         frame = nil
         @client.on(:altsvc) do |f|
           frame = f
         end
 
-        @client << f.generate(ALTSVC.deep_dup.merge(origin: nil))
+        @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.deep_dup
+        s.send headers_frame
         s.close
 
         frame = nil
         s.on(:altsvc) { |f| frame = f }
 
-        @client << set_stream_id(f.generate(ALTSVC.deep_dup.merge(origin: nil)), s.id)
+        @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.deep_dup
+        s.send headers_frame
         s.close
 
         frame = nil
         s.on(:altsvc) { |f| frame = f }
 
-        @client << set_stream_id(f.generate(ALTSVC.deep_dup), s.id)
+        @client << set_stream_id(f.generate(altsvc_frame), s.id)
 
         expect(frame).to be_nil
       end

data/spec/compressor_spec.rb

@@ -236,6 +236,12 @@ 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

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,21 +9,21 @@ RSpec.describe HTTP2::Connection do
   let(:f) { Framer.new }
 
   context 'initialization and settings' do
-    (FRAME_TYPES - [SETTINGS]).each do |frame|
-      it "should raise error if first frame is #{frame[:type]}" do
+    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
 
     it 'should not raise error if first frame is SETTINGS' do
-      expect { @conn << f.generate(SETTINGS.dup) }.to_not raise_error
+      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
@@ -41,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)
@@ -49,8 +50,24 @@ 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]]
 
       # We should expect two frames here (append .twice) - one for the connection setup, and one for the settings ack.
@@ -75,34 +92,34 @@ 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
@@ -110,12 +127,12 @@ RSpec.describe HTTP2::Connection do
     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
 
@@ -123,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
@@ -137,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 = [
@@ -173,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|
@@ -204,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)
@@ -221,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)
@@ -229,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
@@ -275,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
 
@@ -295,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
@@ -315,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)
@@ -326,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
@@ -338,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
@@ -370,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
@@ -381,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
@@ -482,44 +514,44 @@ 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
@@ -536,8 +568,8 @@ RSpec.describe HTTP2::Connection do
     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
 
@@ -545,26 +577,26 @@ RSpec.describe HTTP2::Connection do
       @conn.goaway
       expect(@conn).to be_closed
 
-      expect { @conn << f.generate(SETTINGS.dup) }.not_to raise_error(ProtocolError)
-      expect { @conn << f.generate(PING.dup) }.not_to raise_error(ProtocolError)
-      expect { @conn << f.generate(GOAWAY.dup) }.not_to raise_error(ProtocolError)
+      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
 
@@ -573,12 +605,12 @@ RSpec.describe HTTP2::Connection do
       srv << CONNECTION_PREFACE_MAGIC
 
       stream = srv.new_stream
-      stream.send HEADERS.dup
-      stream.send DATA.dup
+      stream.send headers_frame
+      stream.send data_frame
       stream.close
 
       expect do
-        srv << f.generate(RST_STREAM.dup.merge(stream: stream.id))
+        srv << f.generate(rst_stream_frame.merge(stream: stream.id))
       end.to_not raise_error
     end
 
@@ -596,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
 
@@ -625,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