http-2 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60d5e715ae277807ca53b015a14a0e8c7f6676b7
-  data.tar.gz: 17c562bfb62b6db7209962ace7bd698a59fa2c91
+  metadata.gz: 2a5b4286258966b81acdfc845ae3dda4380c4f64
+  data.tar.gz: 7f61a80280bc7b85f220a6e6661d594d588f0969
 SHA512:
-  metadata.gz: c8d072f9ac4302506d4770fd48fa153567812b2beaa2e0bc4e1f3d04b0cc7560ebf7bd6bc22335e0465814a08a70cdca9f52546b62ffbc362edea5ecfaf41103
-  data.tar.gz: 950e2e78ff84257d62ddaf9d246b31e68689fd8125ee5fb180d239dbeaabe72d373c5a166353000a27d46f3f41c3924de19fa2287c195f7b75215204ae05e78f
+  metadata.gz: 90e4326062ff7d6ee5161ffe0509a99ac46f36c5aebe906b8ec6e044018d36fab1a8e17cf549a30272a5c6a1d7603362eb2fac42edbcc5a666f9b336cdf4bdc4
+  data.tar.gz: fc4ed18e276fbd8d27dbf090999f989d91450bd8a2dd59d9a1e77bdaa482e74217a4f7ecb0bf9033af99c40df29858d88c849a7cba36e19363c43718cc026aa4

data/.rubocop.yml

@@ -8,25 +8,41 @@ AllCops:
     - 'vendor/**/*'
     - '**/huffman_statemachine.rb'
 
+Layout/IndentHeredoc:
+  Exclude:
+    - 'lib/tasks/generate_huffman_table.rb'
+
 Metrics/LineLength:
   Max: 120
 
-Lint/EndAlignment:
-  AlignWith: variable
+Metrics/BlockLength:
+  Max: 700
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: variable
 
-Style/CaseIndentation:
-  IndentWhenRelativeTo: end
+Layout/CaseIndentation:
+  EnforcedStyle: end
 
-Style/IndentHash:
+Layout/IndentHash:
   EnforcedStyle: consistent
 
-Style/TrailingCommaInLiteral:
+Style/TrailingCommaInArrayLiteral:
   EnforcedStyleForMultiline: comma
 
-Style/SpaceAroundOperators:
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+Layout/SpaceAroundOperators:
   Enabled: false
 
-Style/ExtraSpacing:
+Layout/ExtraSpacing:
+  Enabled: false
+
+Layout/EmptyLinesAroundExceptionHandlingKeywords:
+  Enabled: false
+
+Naming/UncommunicativeMethodParamName:
   Enabled: false
 
 Style/SignalException:
@@ -44,14 +60,33 @@ Style/ParenthesesAroundCondition:
 Style/IfInsideElse:
   Enabled: false
 
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+Lint/EmptyWhen:
+  Enabled: false
+
 Style/TrailingCommaInArguments:
   Enabled: false
 
 Style/TrailingUnderscoreVariable:
   Enabled: false
 
+Style/SymbolArray:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
 Performance/TimesMap:
   Enabled: false
 
 Performance/RedundantBlockCall:
   Enabled: false
+

data/.rubocop_todo.yml

@@ -75,14 +75,14 @@ Style/GuardClause:
 # Cop supports --auto-correct.
 # Configuration parameters: SupportedStyles, IndentationWidth.
 # SupportedStyles: special_inside_parentheses, consistent, align_brackets
-Style/IndentArray:
+Layout/IndentArray:
   EnforcedStyle: consistent
 
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: symmetrical, new_line, same_line
-Style/MultilineArrayBraceLayout:
+Layout/MultilineArrayBraceLayout:
   Exclude:
     - 'spec/compressor_spec.rb'
 
@@ -90,7 +90,7 @@ Style/MultilineArrayBraceLayout:
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: symmetrical, new_line, same_line
-Style/MultilineHashBraceLayout:
+Layout/MultilineHashBraceLayout:
   Exclude:
     - 'spec/compressor_spec.rb'
 

data/.travis.yml

@@ -5,7 +5,7 @@ rvm:
   - 2.2
   - 2.3.0
   - 2.4.0
-  - jruby-9.1.8.0
+  - jruby-9.2.0.0 # latest stable
   - jruby-head
   - rbx-2
 matrix:

data/Gemfile

@@ -10,7 +10,7 @@ group :test do
   gem 'pry-byebug', platform: :mri
   gem 'rspec', '~> 3.4.0'
   gem 'rspec-autotest'
-  gem 'rubocop', '0.43.0'
+  gem 'rubocop', '0.57.2'
 end
 
 gemspec

data/Guardfile

@@ -1,4 +1,3 @@
-
 guard :process, name: 'HTTP/2 Server', command: 'ruby example/server.rb', stop_signal: 'TERM' do
   watch(%r{^example/(.+)\.rb$})
   watch(%r{^lib/http/2/(.+)\.rb$})

data/README.md

@@ -1,16 +1,16 @@
 # HTTP-2
 
-[![Gem Version](https://badge.fury.io/rb/http-2.png)](http://rubygems.org/gems/http-2)
-[![Build Status](https://travis-ci.org/igrigorik/http-2.png?branch=master)](https://travis-ci.org/igrigorik/http-2)
-[![Coverage Status](https://coveralls.io/repos/igrigorik/http-2/badge.png)](https://coveralls.io/r/igrigorik/http-2)
+[![Gem Version](https://badge.fury.io/rb/http-2.svg)](http://rubygems.org/gems/http-2)
+[![Build Status](https://travis-ci.org/igrigorik/http-2.svg?branch=master)](https://travis-ci.org/igrigorik/http-2)
+[![Coverage Status](https://coveralls.io/repos/igrigorik/http-2/badge.svg)](https://coveralls.io/r/igrigorik/http-2)
 [![Analytics](https://ga-beacon.appspot.com/UA-71196-10/http-2/readme)](https://github.com/igrigorik/ga-beacon)
 
 Pure Ruby, framework and transport agnostic, implementation of HTTP/2 protocol and HPACK header compression with support for:
 
-* [Binary framing](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_binary_framing_layer) parsing and encoding
-* [Stream multiplexing](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_STREAMS_MESSAGES_FRAMES) and [prioritization](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PRIORITIZATION)
-* Connection and stream [flow control](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_flow_control)
-* [Header compression](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_HEADER_COMPRESSION) and [server push](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PUSH)
+* [Binary framing](https://hpbn.co/http2/#binary-framing-layer) parsing and encoding
+* [Stream multiplexing](https://hpbn.co/http2/#streams-messages-and-frames) and [prioritization](https://hpbn.co/http2/#stream-prioritization)
+* Connection and stream [flow control](https://hpbn.co/http2/#flow-control)
+* [Header compression](https://hpbn.co/http2/#header-compression) and [server push](https://hpbn.co/http2/#server-push)
 * Connection and stream management
 * And more... see [API docs](http://www.rubydoc.info/github/igrigorik/http-2/frames)
 
@@ -88,7 +88,7 @@ Events emitted by the connection object:
 
 ### Stream lifecycle management
 
-A single HTTP/2 connection can [multiplex multiple streams](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#REQUEST_RESPONSE_MULTIPLEXING) in parallel: multiple requests and responses can be in flight simultaneously and stream data can be interleaved and prioritized. Further, the specification provides a well-defined lifecycle for each stream (see below).
+A single HTTP/2 connection can [multiplex multiple streams](https://hpbn.co/http2/#request-and-response-multiplexing) in parallel: multiple requests and responses can be in flight simultaneously and stream data can be interleaved and prioritized. Further, the specification provides a well-defined lifecycle for each stream (see below).
 
 The good news is, all of the stream management, and state transitions, and error checking is handled by the library. All you have to do is subscribe to appropriate events (marked with ":" prefix in diagram below) and provide your application logic to handle request and response processing.
 
@@ -186,7 +186,7 @@ Events emitted by the [Stream object](http://www.rubydoc.info/github/igrigorik/h
 
 ### Prioritization
 
-Each HTTP/2 [stream has a priority value](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PRIORITIZATION) that can be sent when the new stream is initialized, and optionally reprioritized later:
+Each HTTP/2 [stream has a priority value](https://hpbn.co/http2/#stream-prioritization) that can be sent when the new stream is initialized, and optionally reprioritized later:
 
 ```ruby
 client = HTTP2::Client.new
@@ -203,7 +203,7 @@ On the opposite side, the server can optimize its stream processing order or res
 
 ### Flow control
 
-Multiplexing multiple streams over the same TCP connection introduces contention for shared bandwidth resources. Stream priorities can help determine the relative order of delivery, but priorities alone are insufficient to control how the resource allocation is performed between multiple streams. To address this, HTTP/2 provides a simple mechanism for [stream and connection flow control](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_flow_control).
+Multiplexing multiple streams over the same TCP connection introduces contention for shared bandwidth resources. Stream priorities can help determine the relative order of delivery, but priorities alone are insufficient to control how the resource allocation is performed between multiple streams. To address this, HTTP/2 provides a simple mechanism for [stream and connection flow control](https://hpbn.co/http2/#flow-control).
 
 Connection and stream flow control is handled by the library: all streams are initialized with the default window size (64KB), and send/receive window updates are automatically processed - i.e. window is decremented on outgoing data transfers, and incremented on receipt of window frames. Similarly, if the window is exceeded, then data frames are automatically buffered until window is updated.
 
@@ -219,16 +219,10 @@ stream.window              # check current window size
 stream.window_update(2048) # increment stream window by 2048 bytes
 ```
 
-Alternatively, flow control can be disabled by emitting an appropriate settings frame on the connection:
-
-```ruby
-# limit number of concurrent streams to 100 and disable flow control
-conn.settings(streams: 100, window: Float::INFINITY)
-```
 
 ### Server push
 
-An HTTP/2 server can [send multiple replies](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PUSH) to a single client request. To do so, first it emits a "push promise" frame which contains the headers of the promised resource, followed by the response to the original request, as well as promised resource payloads (which may be interleaved). A simple example is in order:
+An HTTP/2 server can [send multiple replies](https://hpbn.co/http2/#server-push) to a single client request. To do so, first it emits a "push promise" frame which contains the headers of the promised resource, followed by the response to the original request, as well as promised resource payloads (which may be interleaved). A simple example is in order:
 
 ```ruby
 conn = HTTP2::Server.new
@@ -276,10 +270,10 @@ conn.on(:promise) do |push|
 end
 ```
 
-The client can cancel any given push stream (via `.close`), or disable server push entirely by sending the appropriate settings frame (note that below setting only impacts server > client direction):
+The client can cancel any given push stream (via `.close`), or disable server push entirely by sending the appropriate settings frame:
 
 ```ruby
-client.settings(streams: 0) # setting max limit to 0 disables server push
+client.settings(settings_enable_push: 0)
 ```
 ### Specs
 

data/example/client.rb

@@ -114,7 +114,7 @@ while !sock.closed? && !sock.eof?
 
   begin
     conn << data
-  rescue => e
+  rescue StandardError => e
     puts "#{e.class} exception: #{e.message} - closing socket."
     e.backtrace.each { |l| puts "\t" + l }
     sock.close

data/example/server.rb

@@ -130,7 +130,7 @@ loop do
 
     begin
       conn << data
-    rescue => e
+    rescue StandardError => e
       puts "#{e.class} exception: #{e.message} - closing socket."
       e.backtrace.each { |l| puts "\t" + l }
       sock.close

data/example/upgrade_client.rb

@@ -34,16 +34,16 @@ end
 
 # upgrader module
 class UpgradeHandler
-  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: */*
+  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
+  RESP
 
   attr_reader :complete, :parsing
   def initialize(conn, sock)
@@ -73,9 +73,9 @@ RESP
     @complete = true
   end
 
-  def on_headers_complete(h)
-    @headers.merge!(h)
-    puts "received headers: #{h}"
+  def on_headers_complete(headers)
+    @headers.merge!(headers)
+    puts "received headers: #{headers}"
   end
 
   def on_body(chunk)
@@ -144,8 +144,7 @@ while !sock.closed? && !sock.eof?
     elsif uh.complete
       conn << data
     end
-
-  rescue => e
+  rescue StandardError => e
     puts "#{e.class} exception: #{e.message} - closing socket."
     e.backtrace.each { |l| puts "\t" + l }
     conn.close

data/example/upgrade_server.rb

@@ -39,12 +39,12 @@ end
 
 class UpgradeHandler
   VALID_UPGRADE_METHODS = %w(GET OPTIONS).freeze
-  UPGRADE_RESPONSE = <<-RESP
-HTTP/1.1 101 Switching Protocols
-Connection: Upgrade
-Upgrade: h2c
+  UPGRADE_RESPONSE = <<-RESP.strip_heredoc.freeze
+    HTTP/1.1 101 Switching Protocols
+    Connection: Upgrade
+    Upgrade: h2c
 
-RESP
+  RESP
 
   attr_reader :complete, :headers, :body, :parsing
 
@@ -191,7 +191,7 @@ loop do
         conn << data
       end
 
-    rescue => e
+    rescue StandardError => e
       puts "Exception: #{e}, #{e.message} - closing socket."
       puts e.backtrace.last(10).join("\n")
       sock.close

data/http-2.gemspec

@@ -1,5 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('./lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'http/2/version'
 

data/lib/http/2/client.rb

@@ -51,7 +51,7 @@ module HTTP2
       @state = :connected
       emit(:frame, CONNECTION_PREFACE_MAGIC)
 
-      payload = @local_settings.select { |k, v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
+      payload = @local_settings.reject { |k, v| v == SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
       settings(payload)
     end
 

data/lib/http/2/compressor.rb

@@ -445,7 +445,8 @@ module HTTP2
       # @return [Buffer]
       def encode(headers)
         buffer = Buffer.new
-
+        pseudo_headers, regular_headers = headers.partition { |f, _| f.start_with? ':' }
+        headers = [*pseudo_headers, *regular_headers]
         commands = @cc.encode(headers)
         commands.each do |cmd|
           buffer << header(cmd)
@@ -549,7 +550,16 @@ module HTTP2
       # @return [Array] +[[name, value], ...]+
       def decode(buf)
         list = []
-        list << @cc.process(header(buf)) until buf.empty?
+        decoding_pseudo_headers = true
+        until buf.empty?
+          next_header = @cc.process(header(buf))
+          is_pseudo_header = next_header.first.start_with? ':'
+          if !decoding_pseudo_headers && is_pseudo_header
+            fail ProtocolError, 'one or more pseudo headers encountered after regular headers'
+          end
+          decoding_pseudo_headers = is_pseudo_header
+          list << next_header
+        end
         list.compact
       end
     end

data/lib/http/2/connection.rb

@@ -20,9 +20,9 @@ module HTTP2
 
   DEFAULT_CONNECTION_SETTINGS = {
     settings_header_table_size:       4096,
-    settings_enable_push:             1,     # enabled for servers
+    settings_enable_push:             1,                     # enabled for servers
     settings_max_concurrent_streams:  100,
-    settings_initial_window_size:     65_535, #
+    settings_initial_window_size:     65_535,
     settings_max_frame_size:          16_384,
     settings_max_header_list_size:    2**31 - 1,             # unlimited
   }.freeze
@@ -96,6 +96,10 @@ module HTTP2
       @h2c_upgrade = nil
     end
 
+    def closed?
+      @state == :closed
+    end
+
     # Allocates new stream for current connection.
     #
     # @param priority [Integer]
@@ -350,7 +354,7 @@ module HTTP2
         end
       end
 
-    rescue => e
+    rescue StandardError => e
       raise if e.is_a?(Error::Error)
       connection_error(e: e)
     end
@@ -492,7 +496,7 @@ module HTTP2
           # allowed frame size (2^24-1 or 16,777,215 octets), inclusive.
           # Values outside this range MUST be treated as a connection error
           # (Section 5.4.1) of type PROTOCOL_ERROR.
-          unless 16_384 <= v && v <= 16_777_215
+          unless v >= 16_384 && v <= 16_777_215
             return ProtocolError.new("invalid #{key} value")
           end
         when :settings_max_header_list_size
@@ -602,8 +606,12 @@ module HTTP2
         frame[:payload] = @decompressor.decode(frame[:payload])
       end
 
-    rescue => e
+    rescue CompressionError => e
       connection_error(:compression_error, e: e)
+    rescue ProtocolError => e
+      connection_error(:protocol_error, e: e)
+    rescue StandardError => e
+      connection_error(:internal_error, e: e)
     end
 
     # Encode headers payload and update connection compressor state.
@@ -633,7 +641,7 @@ module HTTP2
 
       frames
 
-    rescue => e
+    rescue StandardError => e
       connection_error(:compression_error, e: e)
       nil
     end
@@ -701,4 +709,5 @@ module HTTP2
       yield
     end
   end
+  # rubocop:enable ClassLength
 end

data/lib/http/2/framer.rb

@@ -359,14 +359,14 @@ module HTTP2
         if frame[:flags].include? :priority
           e_sd = payload.read_uint32
           frame[:stream_dependency] = e_sd & RBIT
-          frame[:exclusive] = (e_sd & EBIT) != 0 # rubocop:disable Style/NumericPredicate
+          frame[:exclusive] = (e_sd & EBIT) != 0
           frame[:weight] = payload.getbyte + 1
         end
         frame[:payload] = payload.read(frame[:length])
       when :priority
         e_sd = payload.read_uint32
         frame[:stream_dependency] = e_sd & RBIT
-        frame[:exclusive] = (e_sd & EBIT) != 0 # rubocop:disable Style/NumericPredicate
+        frame[:exclusive] = (e_sd & EBIT) != 0
         frame[:weight] = payload.getbyte + 1
       when :rst_stream
         frame[:error] = unpack_error payload.read_uint32
@@ -442,4 +442,5 @@ module HTTP2
       name || error
     end
   end
+  # rubocop:enable ClassLength
 end

data/lib/http/2/stream.rb

@@ -91,6 +91,10 @@ module HTTP2
       on(:local_window) { |v| @local_window_max_size = @local_window = v }
     end
 
+    def closed?
+      @state == :closed
+    end
+
     # Processes incoming HTTP 2.0 frames. The frames must be decoded upstream.
     #
     # @param frame [Hash]
@@ -144,6 +148,7 @@ module HTTP2
     end
 
     # Sends a HEADERS frame containing HTTP response headers.
+    # All pseudo-header fields MUST appear in the header block before regular header fields.
     #
     # @param headers [Array or Hash] Array of key-value pairs or Hash
     # @param end_headers [Boolean] indicates that no more headers will be sent

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = '0.9.1'.freeze
+  VERSION = '0.10.0'.freeze
 end

data/spec/compressor_spec.rb

@@ -351,6 +351,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,
@@ -485,25 +557,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
@@ -513,6 +598,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
@@ -522,22 +608,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

@@ -8,14 +8,18 @@ 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_TYPES - [SETTINGS]).each do |frame|
+      it "should raise error if first frame is #{frame[:type]}" do
         frame = set_stream_id(f.generate(frame.deep_dup), 0x0)
-        expect { @conn.dup << frame }.to raise_error(ProtocolError)
+        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.state).to eq :connected
+      expect(@conn).to_not be_closed
     end
 
     it 'should raise error if SETTINGS stream != 0' do
@@ -50,13 +54,19 @@ RSpec.describe HTTP2::Connection do
       settings = SETTINGS.dup
       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
 
@@ -95,6 +105,9 @@ RSpec.describe HTTP2::Connection do
       s1.receive DATA
       s2.send DATA.dup
       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
@@ -512,10 +525,14 @@ RSpec.describe HTTP2::Connection do
       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
 

data/spec/framer_spec.rb

@@ -341,11 +341,11 @@ RSpec.describe HTTP2::Framer do
         length: 44,
         type: :altsvc,
         stream: 1,
-        max_age: 1_402_290_402,	   # 4
-        port: 8080,		   # 2
-        proto: 'h2-13',		   # 1 + 5
-        host: 'www.example.com',   # 1 + 15
-        origin: 'www.example.com', # 15
+        max_age: 1_402_290_402,     # 4
+        port: 8080,                 # 2
+        proto: 'h2-13',             # 1 + 5
+        host: 'www.example.com',    # 1 + 15
+        origin: 'www.example.com',  # 15
       }
       bytes = f.generate(frame)
       expected = [0, 43, 0xa, 0, 1, 1_402_290_402, 8080].pack('CnCCNNn')

data/spec/helper.rb

@@ -10,9 +10,11 @@ Coveralls.wear! if ENV['CI']
 
 require 'http/2'
 
+# rubocop: disable Style/MixinUsage
 include HTTP2
 include HTTP2::Header
 include HTTP2::Error
+# rubocop: enable Style/MixinUsage
 
 DATA = {
   type: :data,

data/spec/stream_spec.rb

@@ -194,6 +194,7 @@ RSpec.describe HTTP2::Stream do
       it 'should transition to closed if sending RST_STREAM' do
         @stream.close
         expect(@stream.state).to eq :closed
+        expect(@stream).to be_closed
       end
 
       it 'should transition to closed if receiving RST_STREAM' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http-2
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Ilya Grigorik
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-06 00:00:00.000000000 Z
+date: 2018-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler