mieps_http-2 0.8.0

data/spec/compressor_spec.rb

@@ -0,0 +1,535 @@
+require 'helper'
+
+RSpec.describe HTTP2::Header do
+  let(:c) { Compressor.new }
+  let(:d) { Decompressor.new }
+
+  context 'literal representation' do
+    context 'integer' do
+      it 'should encode 10 using a 5-bit prefix' do
+        buf = c.integer(10, 5)
+        expect(buf).to eq [10].pack('C')
+        expect(d.integer(Buffer.new(buf), 5)).to eq 10
+      end
+
+      it 'should encode 10 using a 0-bit prefix' do
+        buf = c.integer(10, 0)
+        expect(buf).to eq [10].pack('C')
+        expect(d.integer(Buffer.new(buf), 0)).to eq 10
+      end
+
+      it 'should encode 1337 using a 5-bit prefix' do
+        buf = c.integer(1337, 5)
+        expect(buf).to eq [31, 128 + 26, 10].pack('C*')
+        expect(d.integer(Buffer.new(buf), 5)).to eq 1337
+      end
+
+      it 'should encode 1337 using a 0-bit prefix' do
+        buf = c.integer(1337, 0)
+        expect(buf).to eq [128 + 57, 10].pack('C*')
+        expect(d.integer(Buffer.new(buf), 0)).to eq 1337
+      end
+    end
+
+    context 'string' do
+      [
+        ['with huffman',    :always, 0x80],
+        ['without huffman', :never,  0],
+      ].each do |desc, option, msb|
+        let(:trailer) { 'trailer' }
+
+        [
+          ['ascii codepoints', 'abcdefghij'],
+          ['utf-8 codepoints', 'éáűőúöüó€'],
+          ['long utf-8 strings', 'éáűőúöüó€' * 100],
+        ].each do |datatype, plain|
+          it "should handle #{datatype} #{desc}" do
+            # NOTE: don't put this new in before{} because of test case shuffling
+            @c = Compressor.new(huffman: option)
+            str = @c.string(plain)
+            expect(str.getbyte(0) & 0x80).to eq msb
+
+            buf = Buffer.new(str + trailer)
+            expect(d.string(buf)).to eq plain
+            expect(buf).to eq trailer
+          end
+        end
+      end
+      context 'choosing shorter representation' do
+        [['日本語', :plain],
+         ['200', :huffman],
+         ['xq', :plain],   # prefer plain if equal size
+        ].each do |string, choice|
+          before { @c = Compressor.new(huffman: :shorter) }
+
+          it "should return #{choice} representation" do
+            wire = @c.string(string)
+            expect(wire.getbyte(0) & 0x80).to eq(choice == :plain ? 0 : 0x80)
+          end
+        end
+      end
+    end
+  end
+
+  context 'header representation' do
+    it 'should handle indexed representation' do
+      h = { name: 10, type: :indexed }
+      wire = c.header(h)
+      expect(wire.readbyte(0) & 0x80).to eq 0x80
+      expect(wire.readbyte(0) & 0x7f).to eq h[:name] + 1
+      expect(d.header(wire)).to eq h
+    end
+    it 'should raise when decoding indexed representation with index zero' do
+      h = { name: 10, type: :indexed }
+      wire = c.header(h)
+      wire[0] = 0x80.chr(Encoding::BINARY)
+      expect { d.header(wire) }.to raise_error CompressionError
+    end
+
+    context 'literal w/o indexing representation' do
+      it 'should handle indexed header' do
+        h = { name: 10, value: 'my-value', type: :noindex }
+        wire = c.header(h)
+        expect(wire.readbyte(0) & 0xf0).to eq 0x0
+        expect(wire.readbyte(0) & 0x0f).to eq h[:name] + 1
+        expect(d.header(wire)).to eq h
+      end
+
+      it 'should handle literal header' do
+        h = { name: 'x-custom', value: 'my-value', type: :noindex }
+        wire = c.header(h)
+        expect(wire.readbyte(0) & 0xf0).to eq 0x0
+        expect(wire.readbyte(0) & 0x0f).to eq 0
+        expect(d.header(wire)).to eq h
+      end
+    end
+
+    context 'literal w/ incremental indexing' do
+      it 'should handle indexed header' do
+        h = { name: 10, value: 'my-value', type: :incremental }
+        wire = c.header(h)
+        expect(wire.readbyte(0) & 0xc0).to eq 0x40
+        expect(wire.readbyte(0) & 0x3f).to eq h[:name] + 1
+        expect(d.header(wire)).to eq h
+      end
+
+      it 'should handle literal header' do
+        h = { name: 'x-custom', value: 'my-value', type: :incremental }
+        wire = c.header(h)
+        expect(wire.readbyte(0) & 0xc0).to eq 0x40
+        expect(wire.readbyte(0) & 0x3f).to eq 0
+        expect(d.header(wire)).to eq h
+      end
+    end
+
+    context 'literal never indexed' do
+      it 'should handle indexed header' do
+        h = { name: 10, value: 'my-value', type: :neverindexed }
+        wire = c.header(h)
+        expect(wire.readbyte(0) & 0xf0).to eq 0x10
+        expect(wire.readbyte(0) & 0x0f).to eq h[:name] + 1
+        expect(d.header(wire)).to eq h
+      end
+
+      it 'should handle literal header' do
+        h = { name: 'x-custom', value: 'my-value', type: :neverindexed }
+        wire = c.header(h)
+        expect(wire.readbyte(0) & 0xf0).to eq 0x10
+        expect(wire.readbyte(0) & 0x0f).to eq 0
+        expect(d.header(wire)).to eq h
+      end
+    end
+  end
+
+  context 'shared compression context' do
+    before(:each) { @cc = EncodingContext.new }
+
+    it 'should be initialized with empty headers' do
+      cc = EncodingContext.new
+      expect(cc.table).to be_empty
+    end
+
+    context 'processing' do
+      [
+        ['no indexing', :noindex],
+        ['never indexed', :neverindexed],
+      ].each do |desc, type|
+        context "#{desc}" do
+          it 'should process indexed header with literal value' do
+            original_table = @cc.table.dup
+
+            emit = @cc.process(name: 4, value: '/path', type: type)
+            expect(emit).to eq [':path', '/path']
+            expect(@cc.table).to eq original_table
+          end
+
+          it 'should process literal header with literal value' do
+            original_table = @cc.table.dup
+
+            emit = @cc.process(name: 'x-custom', value: 'random', type: type)
+            expect(emit).to eq ['x-custom', 'random']
+            expect(@cc.table).to eq original_table
+          end
+        end
+      end
+
+      context 'incremental indexing' do
+        it 'should process indexed header with literal value' do
+          original_table = @cc.table.dup
+
+          emit = @cc.process(name: 4, value: '/path', type: :incremental)
+          expect(emit).to eq [':path', '/path']
+          expect(@cc.table - original_table).to eq [[':path', '/path']]
+        end
+
+        it 'should process literal header with literal value' do
+          original_table = @cc.table.dup
+
+          @cc.process(name: 'x-custom', value: 'random', type: :incremental)
+          expect(@cc.table - original_table).to eq [['x-custom', 'random']]
+        end
+      end
+
+      context 'size bounds' do
+        it 'should drop headers from end of table' do
+          cc = EncodingContext.new(table_size: 2048)
+          cc.instance_eval do
+            add_to_table(['test1', '1' * 1024])
+            add_to_table(['test2', '2' * 500])
+          end
+
+          original_table = cc.table.dup
+          original_size = original_table.join.bytesize + original_table.size * 32
+
+          cc.process(name: 'x-custom',
+                     value: 'a' * (2048 - original_size),
+                     type: :incremental)
+
+          expect(cc.table.first[0]).to eq 'x-custom'
+          expect(cc.table.size).to eq original_table.size # number of entries
+        end
+      end
+
+      it 'should clear table if entry exceeds table size' do
+        cc = EncodingContext.new(table_size: 2048)
+        cc.instance_eval do
+          add_to_table(['test1', '1' * 1024])
+          add_to_table(['test2', '2' * 500])
+        end
+
+        h = { name: 'x-custom', value: 'a', index: 0, type: :incremental }
+        e = { name: 'large', value: 'a' * 2048, index: 0 }
+
+        cc.process(h)
+        cc.process(e.merge(type: :incremental))
+        expect(cc.table).to be_empty
+      end
+
+      it 'should shrink table if set smaller size' do
+        cc = EncodingContext.new(table_size: 2048)
+        cc.instance_eval do
+          add_to_table(['test1', '1' * 1024])
+          add_to_table(['test2', '2' * 500])
+        end
+
+        cc.process(type: :changetablesize, value: 1500)
+        expect(cc.table.size).to be 1
+        expect(cc.table.first[0]).to eq 'test2'
+      end
+    end
+  end
+
+  spec_examples = [
+    { title: 'D.3. Request Examples without Huffman',
+      type: :request,
+      table_size: 4096,
+      huffman: :never,
+      streams: [
+        { wire: "8286 8441 0f77 7777 2e65 7861 6d70 6c65
+                 2e63 6f6d",
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 57,
+        },
+        { wire: '8286 84be 5808 6e6f 2d63 6163 6865',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+            ['cache-control', 'no-cache'],
+          ],
+          table: [
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 110,
+        },
+        { wire: "8287 85bf 400a 6375 7374 6f6d 2d6b 6579
+                 0c63 7573 746f 6d2d 7661 6c75 65",
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'https'],
+            [':path', '/index.html'],
+            [':authority', 'www.example.com'],
+            ['custom-key', 'custom-value'],
+          ],
+          table: [
+            ['custom-key', 'custom-value'],
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 164,
+        },
+      ],
+    },
+    { title: 'D.4.  Request Examples with Huffman',
+      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'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+            ['cache-control', 'no-cache'],
+          ],
+          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'],
+            [':path', '/index.html'],
+            [':authority', 'www.example.com'],
+            ['custom-key', 'custom-value'],
+          ],
+          table: [
+            ['custom-key', 'custom-value'],
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 164,
+        },
+      ],
+    },
+    { title: 'D.5.  Response Examples without Huffman',
+      type: :response,
+      table_size: 256,
+      huffman: :never,
+      streams: [
+        { wire: "4803 3330 3258 0770 7269 7661 7465 611d
+                 4d6f 6e2c 2032 3120 4f63 7420 3230 3133
+                 2032 303a 3133 3a32 3120 474d 546e 1768
+                 7474 7073 3a2f 2f77 7777 2e65 7861 6d70
+                 6c65 2e63 6f6d",
+          emitted: [
+            [':status', '302'],
+            ['cache-control', 'private'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['location', 'https://www.example.com'],
+          ],
+          table: [
+            ['location', 'https://www.example.com'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['cache-control', 'private'],
+            [':status', '302'],
+          ],
+          table_size: 222,
+        },
+        { wire: '4803 3330 37c1 c0bf',
+          emitted: [
+            [':status', '307'],
+            ['cache-control', 'private'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['location', 'https://www.example.com'],
+          ],
+          table: [
+            [':status', '307'],
+            ['location', 'https://www.example.com'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['cache-control', 'private'],
+          ],
+          table_size: 222,
+        },
+        { wire: "88c1 611d 4d6f 6e2c 2032 3120 4f63 7420
+                 3230 3133 2032 303a 3133 3a32 3220 474d
+                 54c0 5a04 677a 6970 7738 666f 6f3d 4153
+                 444a 4b48 514b 425a 584f 5157 454f 5049
+                 5541 5851 5745 4f49 553b 206d 6178 2d61
+                 6765 3d33 3630 303b 2076 6572 7369 6f6e
+                 3d31",
+          emitted: [
+            [':status', '200'],
+            ['cache-control', 'private'],
+            ['date', 'Mon, 21 Oct 2013 20:13:22 GMT'],
+            ['location', 'https://www.example.com'],
+            ['content-encoding', 'gzip'],
+            ['set-cookie', 'foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1'],
+          ],
+          table: [
+            ['set-cookie', 'foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1'],
+            ['content-encoding', 'gzip'],
+            ['date', 'Mon, 21 Oct 2013 20:13:22 GMT'],
+          ],
+          table_size: 215,
+        },
+      ],
+    },
+    { title: 'D.6.  Response Examples with Huffman',
+      type: :response,
+      table_size: 256,
+      huffman: :always,
+      streams: [
+        { wire: "4882 6402 5885 aec3 771a 4b61 96d0 7abe
+                 9410 54d4 44a8 2005 9504 0b81 66e0 82a6
+                 2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8
+                 e9ae 82ae 43d3",
+          emitted: [
+            [':status', '302'],
+            ['cache-control', 'private'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['location', 'https://www.example.com'],
+          ],
+          table: [
+            ['location', 'https://www.example.com'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['cache-control', 'private'],
+            [':status', '302'],
+          ],
+          table_size: 222,
+        },
+        { wire: '4883 640e ffc1 c0bf',
+          emitted: [
+            [':status', '307'],
+            ['cache-control', 'private'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['location', 'https://www.example.com'],
+          ],
+          table: [
+            [':status', '307'],
+            ['location', 'https://www.example.com'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['cache-control', 'private'],
+          ],
+          table_size: 222,
+        },
+        { wire: "88c1 6196 d07a be94 1054 d444 a820 0595
+                 040b 8166 e084 a62d 1bff c05a 839b d9ab
+                 77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b
+                 3960 d5af 2708 7f36 72c1 ab27 0fb5 291f
+                 9587 3160 65c0 03ed 4ee5 b106 3d50 07",
+          emitted: [
+            [':status', '200'],
+            ['cache-control', 'private'],
+            ['date', 'Mon, 21 Oct 2013 20:13:22 GMT'],
+            ['location', 'https://www.example.com'],
+            ['content-encoding', 'gzip'],
+            ['set-cookie', 'foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1'],
+          ],
+          table: [
+            ['set-cookie', 'foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1'],
+            ['content-encoding', 'gzip'],
+            ['date', 'Mon, 21 Oct 2013 20:13:22 GMT'],
+          ],
+          table_size: 215,
+        },
+      ],
+    },
+  ]
+
+  context 'decode' do
+    spec_examples.each do |ex|
+      context "spec example #{ex[:title]}" do
+        ex[:streams].size.times do |nth|
+          context "request #{nth + 1}" do
+            before { @dc = Decompressor.new(table_size: ex[:table_size]) }
+            before do
+              (0...nth).each do |i|
+                bytes = [ex[:streams][i][:wire].delete(" \n")].pack('H*')
+                @dc.decode(HTTP2::Buffer.new(bytes))
+              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]
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'encode' do
+    spec_examples.each do |ex|
+      context "spec example #{ex[:title]}" do
+        ex[:streams].size.times do |nth|
+          context "request #{nth + 1}" do
+            before do
+              @cc = Compressor.new(table_size: ex[:table_size],
+                                   huffman: ex[:huffman])
+            end
+            before do
+              (0...nth).each do |i|
+                @cc.encode(ex[:streams][i][:emitted])
+              end
+            end
+            subject do
+              @cc.encode(ex[:streams][nth][:emitted])
+            end
+            it 'should emit expected bytes on wire' do
+              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]
+            end
+          end
+        end
+      end
+    end
+  end
+end