http-2 0.10.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f52820ad290d538c293b8d008baa622bc788c07c
-  data.tar.gz: 93aa6df1ade7720059e84c8ffd69d1fb2385028d
+SHA256:
+  metadata.gz: 8dd78ba6a3468b6a3ceda2ebabc37ceb895a90d675d9fecc035b74d2f479a457
+  data.tar.gz: d70542d69e57050ab9ee3c837b6123fea81424a03bf3b99ffdc889a54a2fd20c
 SHA512:
-  metadata.gz: d8fb28dd5124a1dc9995f250ca82a0a257d5a1c2a4b802fadcf0d7fe30a054c1e1e312fa81f6bb69888103783d23916c3bdb464c5eb5819e2ef68609ddeae303
-  data.tar.gz: 82f8859ce4752d46be361deb76e1b37b076472b0b07262ca5aa9d7b2daa2c50d6d28b44aa8811031b58a294424c1e8fc056f22ffd9c92301a48b2369503784ae
+  metadata.gz: f678316f6235ed93ce5a3902ef3bf4c48854605de0875054d1f3e05196fc161bdfe49d149ff930413bef5ca76c61ab2d193092867a383f1f5dbe309cfef0f012
+  data.tar.gz: 52fce71379a9299df1cd8c93d44964d668d09c199564482193513b109a6339f220b4ae1e724c5965892b3e53855820a810e95405b8eb198797ea130611d39a05

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

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

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.
@@ -683,13 +686,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 +697,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.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
@@ -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)
@@ -50,7 +51,7 @@ 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]]
 
       # We should expect two frames here (append .twice) - one for the connection setup, and one for the settings ack.
@@ -75,34 +76,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 +111,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 +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
@@ -137,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 = [
@@ -173,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|
@@ -204,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)
@@ -221,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)
@@ -229,37 +245,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 +291,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 +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
@@ -315,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)
@@ -326,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
@@ -338,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
@@ -358,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
@@ -370,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
@@ -482,44 +498,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 +552,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 +561,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 +589,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 +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
 
@@ -625,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