amq-protocol 2.3.3 → 2.8.0

data/spec/amq/protocol/table_spec.rb

@@ -1,259 +0,0 @@
-require 'time'
-
-module AMQ
-  module Protocol
-    RSpec.describe Table do
-      timestamp    = Time.utc(2010, 12, 31, 23, 58, 59)
-      bigdecimal_1 = BigDecimal("1.0")
-      bigdecimal_2 = BigDecimal("5E-3")
-
-      DATA = {
-          {}                       => "\x00\x00\x00\x00",
-          {"test" => 1}            => "\x00\x00\x00\x0E\x04testl\x00\x00\x00\x00\x00\x00\x00\x01",
-          {"float" => 1.92}        => "\x00\x00\x00\x0F\x05floatd?\xFE\xB8Q\xEB\x85\x1E\xB8",
-          {"test" => "string"}     => "\x00\x00\x00\x10\x04testS\x00\x00\x00\x06string",
-          {"test" => {}}           => "\x00\x00\x00\n\x04testF\x00\x00\x00\x00",
-          {"test" => bigdecimal_1} => "\x00\x00\x00\v\x04testD\x00\x00\x00\x00\x01",
-          {"test" => bigdecimal_2} => "\x00\x00\x00\v\x04testD\x03\x00\x00\x00\x05",
-          {"test" => timestamp}    => "\x00\x00\x00\x0e\x04testT\x00\x00\x00\x00M\x1enC"
-      }
-
-      describe ".encode" do
-        it "should return \"\x00\x00\x00\x00\" for nil" do
-          encoded_value = "\x00\x00\x00\x00"
-
-          expect(Table.encode(nil)).to eql(encoded_value)
-        end
-
-        it "should serialize { :test => true }" do
-          expect(Table.encode(:test => true)).
-            to eql("\x00\x00\x00\a\x04testt\x01".force_encoding(Encoding::ASCII_8BIT))
-        end
-
-        it "should serialize { :test => false }" do
-          expect(Table.encode(:test => false)).
-            to eql("\x00\x00\x00\a\x04testt\x00".force_encoding(Encoding::ASCII_8BIT))
-        end
-
-        it "should serialize { :coordinates => { :latitude  => 59.35 } }" do
-          expect(Table.encode(:coordinates => { :latitude  => 59.35 })).
-            to eql("\x00\x00\x00#\vcoordinatesF\x00\x00\x00\x12\blatituded@M\xAC\xCC\xCC\xCC\xCC\xCD".force_encoding(Encoding::ASCII_8BIT))
-        end
-
-        it "should serialize { :coordinates => { :longitude => 18.066667 } }" do
-          expect(Table.encode(:coordinates => { :longitude => 18.066667 })).
-            to eql("\x00\x00\x00$\vcoordinatesF\x00\x00\x00\x13\tlongituded@2\x11\x11\x16\xA8\xB8\xF1".force_encoding(Encoding::ASCII_8BIT))
-        end
-
-        it "should serialize long UTF-8 strings and symbols" do
-          long_utf8 = "à" * 192
-          long_ascii8 = long_utf8.dup.force_encoding(::Encoding::ASCII_8BIT)
-
-          input = { "utf8_string" => long_utf8, "utf8_symbol" => long_utf8.to_sym }
-          output = { "utf8_string" => long_ascii8, "utf8_symbol" => long_ascii8 }
-
-          expect(Table.decode(Table.encode(input))).to eq(output)
-        end
-
-        DATA.each do |data, encoded|
-          it "should return #{encoded.inspect} for #{data.inspect}" do
-            expect(Table.encode(data)).to eql(encoded.force_encoding(Encoding::ASCII_8BIT))
-          end
-        end
-      end
-
-      describe ".decode" do
-        DATA.each do |data, encoded|
-          it "should return #{data.inspect} for #{encoded.inspect}" do
-            expect(Table.decode(encoded)).to eql(data)
-          end
-
-          it "is capable of decoding what it encodes" do
-            expect(Table.decode(Table.encode(data))).to eq(data)
-          end
-        end # DATA.each
-
-
-        it "is capable of decoding boolean table values" do
-          input1   = { "boolval" => true }
-          expect(Table.decode(Table.encode(input1))).to eq(input1)
-
-
-          input2   = { "boolval" => false }
-          expect(Table.decode(Table.encode(input2))).to eq(input2)
-        end
-
-
-        it "is capable of decoding nil table values" do
-          input   = { "nilval" => nil }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-        it "is capable of decoding nil table in nested hash/map values" do
-          input   = { "hash" => {"nil" => nil} }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-        it "is capable of decoding string table values" do
-          input   = { "stringvalue" => "string" }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-
-          expect(Table.decode("\x00\x00\x00\x17\vstringvalueS\x00\x00\x00\x06string")).to eq(input)
-        end
-
-        it "is capable of decoding byte array table values (as Ruby strings)" do
-          expect(Table.decode("\x00\x00\x00\x17\vstringvaluex\x00\x00\x00\x06string")).to eq({"stringvalue" => "string"})
-        end
-
-        it "is capable of decoding string table values with UTF-8 characters" do
-          input   = {
-            "строка".force_encoding(::Encoding::ASCII_8BIT) => "значение".force_encoding(::Encoding::ASCII_8BIT)
-          }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-        it "is capable of decoding integer table values" do
-          input   = { "intvalue" => 10 }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-        it "is capable of decoding signed integer table values" do
-          input   = { "intvalue" => -10 }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-        it "is capable of decoding long table values" do
-          input   = { "longvalue" => 912598613 }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding float table values" do
-          input   = { "floatvalue" => 100.0 }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding time table values" do
-          input   = { "intvalue" => Time.parse("2011-07-14 01:17:46 +0400") }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding empty hash table values" do
-          input   = { "hashvalue" => Hash.new }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding empty array table values" do
-          input   = { "arrayvalue" => Array.new }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-        it "is capable of decoding single string value array table values" do
-          input   = { "arrayvalue" => ["amq-protocol"] }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding simple nested hash table values" do
-          input   = { "hashvalue" => { "a" => "b" } }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding nil table values" do
-          input   = { "nil" => nil }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-        it 'is capable of decoding 8bit signed integers' do
-          output = TableValueDecoder.decode_byte("\xC0",0).first
-          expect(output).to eq(192)
-        end
-
-        it 'is capable of decoding 16bit signed integers' do
-          output = TableValueDecoder.decode_short("\x06\x8D", 0).first
-          expect(output).to eq(1677)
-        end
-
-        it "is capable of decoding tables" do
-          input   = {
-            "boolval"      => true,
-            "intval"       => 1,
-            "strval"       => "Test",
-            "timestampval" => Time.parse("2011-07-14 01:17:46 +0400"),
-            "floatval"     => 3.14,
-            "longval"      => 912598613,
-            "hashval"      => { "protocol" => "AMQP091", "true" => true, "false" => false, "nil" => nil }
-          }
-          expect(Table.decode(Table.encode(input))).to eq(input)
-        end
-
-
-
-        it "is capable of decoding deeply nested tables" do
-          input   = {
-            "hashval"    => {
-              "protocol" => {
-                "name"  => "AMQP",
-                "major" => 0,
-                "minor" => "9",
-                "rev"   => 1.0,
-                "spec"  => {
-                  "url"  => "http://bit.ly/hw2ELX",
-                  "utf8" => "à bientôt"
-                }
-              },
-              "true"     => true,
-              "false"    => false,
-              "nil"      => nil
-            }
-          }
-          expect(Table.decode(Table.encode(input))).to eq(input.tap { |r| r["hashval"]["protocol"]["spec"]["utf8"].force_encoding(::Encoding::ASCII_8BIT) })
-        end
-
-
-
-        it "is capable of decoding array values in tables" do
-          input1   = {
-            "arrayval1" => [198, 3, 77, 8.0, ["inner", "array", { "oh" => "well", "it" => "should work", "3" => 6 }], "two", { "a" => "value", "is" => nil }],
-            "arrayval2" => [198, 3, 77, "two", { "a" => "value", "is" => nil }, 8.0, ["inner", "array", { "oh" => "well", "it" => "should work", "3" => 6 }]]
-          }
-          expect(Table.decode(Table.encode(input1))).to eq(input1)
-
-          now = Time.now
-          input2 = {
-                       "coordinates" => {
-                         "latitude"  => 59.35,
-                         "longitude" => 18.066667
-                       },
-                       "participants" => 11,
-                       "venue"        => "Stockholm",
-                       "true_field"   => true,
-                       "false_field"  => false,
-                       "nil_field"    => nil,
-                       "ary_field"    => ["one", 2.0, 3]
-                     }
-
-          expect(Table.decode(Table.encode(input2))).to eq(input2)
-
-          input3 = { "timely" => { "now" => now } }
-          expect(Table.decode(Table.encode(input3))["timely"]["now"].to_i).to eq(now.to_i)
-        end
-
-      end # describe
-    end
-  end
-end

data/spec/amq/protocol/tx_spec.rb

@@ -1,55 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    class Tx
-      RSpec.describe Select do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            method_frame = Select.encode(channel)
-            expect(method_frame.payload).to eq("\000Z\000\n")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe SelectOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Commit do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            method_frame = Commit.encode(channel)
-            expect(method_frame.payload).to eq("\000Z\000\024")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe CommitOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Rollback do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            method_frame = Rollback.encode(channel)
-            expect(method_frame.payload).to eq("\000Z\000\036")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe RollbackOk do
-      #   describe '.decode' do
-      #   end
-      # end
-    end
-  end
-end

data/spec/amq/protocol/value_decoder_spec.rb

@@ -1,86 +0,0 @@
-require 'time'
-require "amq/protocol/table_value_decoder"
-
-module AMQ
-  module Protocol
-    RSpec.describe TableValueDecoder do
-
-      it "is capable of decoding basic arrays TableValueEncoder encodes" do
-        input1 = [1, 2, 3]
-
-        value, _offset = described_class.decode_array(TableValueEncoder.encode(input1), 1)
-        expect(value.size).to eq(3)
-        expect(value.first).to eq(1)
-        expect(value).to eq(input1)
-
-
-
-        input2 = ["one", 2, "three"]
-
-        value, _offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
-        expect(value.size).to eq(3)
-        expect(value.first).to eq("one")
-        expect(value).to eq(input2)
-
-
-
-        input3 = ["one", 2, "three", 4.0, 5000000.0]
-
-        value, _offset = described_class.decode_array(TableValueEncoder.encode(input3), 1)
-        expect(value.size).to eq(5)
-        expect(value.last).to eq(5000000.0)
-        expect(value).to eq(input3)
-      end
-
-
-
-      it "is capable of decoding arrays TableValueEncoder encodes" do
-        input1 = [{ "one" => 2 }, 3]
-        data1  = TableValueEncoder.encode(input1)
-
-        # puts(TableValueEncoder.encode({ "one" => 2 }).inspect)
-        # puts(TableValueEncoder.encode(input1).inspect)
-
-
-        value, _offset = described_class.decode_array(data1, 1)
-        expect(value.size).to eq(2)
-        expect(value.first).to eq(Hash["one" => 2])
-        expect(value).to eq(input1)
-
-
-
-        input2 = ["one", 2, { "three" => { "four" => 5.0 } }]
-
-        value, _offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
-        expect(value.size).to eq(3)
-        expect(value.last["three"]["four"]).to eq(5.0)
-        expect(value).to eq(input2)
-      end
-
-      it "is capable of decoding 32 bit float values" do
-        input = Float32Bit.new(10.0)
-        data  = TableValueEncoder.encode(input)
-
-        value = described_class.decode_32bit_float(data, 1)[0]
-        expect(value).to eq(10.0)
-      end
-
-      context "8bit/byte decoding" do
-        let(:examples) {
-          {
-              0x00 => "\x00",
-              0x01 => "\x01",
-              0x10 => "\x10",
-              255   => "\xFF" # not -1
-          }
-        }
-
-        it "is capable of decoding byte values" do
-          examples.each do |key, value|
-            expect(described_class.decode_byte(value, 0).first).to eq(key)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/amq/protocol/value_encoder_spec.rb

@@ -1,140 +0,0 @@
-require 'time'
-require "amq/protocol/table_value_encoder"
-require "amq/protocol/float_32bit"
-
-module AMQ
-  module Protocol
-    RSpec.describe TableValueEncoder do
-
-      it "calculates size of string field values" do
-        expect(described_class.field_value_size("amqp")).to eq(9)
-        expect(described_class.encode("amqp").bytesize).to eq(9)
-
-        expect(described_class.field_value_size("amq-protocol")).to eq(17)
-        expect(described_class.encode("amq-protocol").bytesize).to eq(17)
-
-        expect(described_class.field_value_size("à bientôt")).to eq(16)
-        expect(described_class.encode("à bientôt").bytesize).to eq(16)
-      end
-
-      it "calculates size of integer field values" do
-        expect(described_class.field_value_size(10)).to eq(9)
-        expect(described_class.encode(10).bytesize).to eq(9)
-      end
-
-      it "calculates size of float field values (considering them to be 64-bit)" do
-        expect(described_class.field_value_size(10.0)).to eq(9)
-        expect(described_class.encode(10.0).bytesize).to eq(9)
-
-        expect(described_class.field_value_size(120000.0)).to eq(9)
-        expect(described_class.encode(120000.0).bytesize).to eq(9)
-      end
-
-      it "calculates size of float field values (boxed as 32-bit)" do
-        expect(described_class.encode(AMQ::Protocol::Float32Bit.new(10.0)).bytesize).to eq(5)
-        expect(described_class.encode(AMQ::Protocol::Float32Bit.new(120000.0)).bytesize).to eq(5)
-      end
-
-      it "calculates size of boolean field values" do
-        expect(described_class.field_value_size(true)).to eq(2)
-        expect(described_class.encode(true).bytesize).to eq(2)
-
-        expect(described_class.field_value_size(false)).to eq(2)
-        expect(described_class.encode(false).bytesize).to eq(2)
-      end
-
-      it "calculates size of void field values" do
-        expect(described_class.field_value_size(nil)).to eq(1)
-        expect(described_class.encode(nil).bytesize).to eq(1)
-      end
-
-      it "calculates size of time field values" do
-        t = Time.parse("2011-07-14 01:17:46 +0400")
-
-        expect(described_class.field_value_size(t)).to eq(9)
-        expect(described_class.encode(t).bytesize).to eq(9)
-      end
-
-
-      it "calculates size of basic table field values" do
-        input1   = { "key" => "value" }
-        expect(described_class.field_value_size(input1)).to eq(19)
-        expect(described_class.encode(input1).bytesize).to eq(19)
-
-
-        input2   = { "intval" => 1 }
-        expect(described_class.field_value_size(input2)).to eq(21)
-        expect(described_class.encode(input2).bytesize).to eq(21)
-
-
-        input3   = { "intval" => 1, "key" => "value" }
-        expect(described_class.field_value_size(input3)).to eq(35)
-        expect(described_class.encode(input3).bytesize).to eq(35)
-      end
-
-
-      it "calculates size of table field values" do
-        input1   = {
-          "hashval"    => {
-            "protocol" => {
-              "name"  => "AMQP",
-              "major" => 0,
-              "minor" => "9",
-              "rev"   => 1.0,
-              "spec"  => {
-                "url"  => "http://bit.ly/hw2ELX",
-                "utf8" => "à bientôt".force_encoding(::Encoding::ASCII_8BIT)
-              }
-            },
-            "true"     => true,
-            "false"    => false,
-            "nil"      => nil
-          }
-        }
-
-        expect(described_class.field_value_size(input1)).to eq(166)
-        # puts(described_class.encode(input1).inspect)
-        expect(described_class.encode(input1).bytesize).to eq(166)
-
-
-
-        input2   = {
-          "boolval"      => true,
-          "intval"       => 1,
-          "strval"       => "Test",
-          "timestampval" => Time.parse("2011-07-14 01:17:46 +0400"),
-          "floatval"     => 3.14,
-          "longval"      => 912598613,
-          "hashval"      => { "protocol" => "AMQP091", "true" => true, "false" => false, "nil" => nil }
-        }
-
-        expect(described_class.field_value_size(input2)).to eq(158)
-        expect(described_class.encode(input2).bytesize).to eq(158)
-      end
-
-      it "calculates size of basic array field values" do
-        input1 = [1, 2, 3]
-
-        expect(described_class.field_value_size(input1)).to eq(32)
-        expect(described_class.encode(input1).bytesize).to eq(32)
-
-
-        input2 = ["one", "two", "three"]
-        expect(described_class.field_value_size(input2)).to eq(31)
-        expect(described_class.encode(input2).bytesize).to eq(31)
-
-
-        input3 = ["one", 2, "three"]
-        expect(described_class.field_value_size(input3)).to eq(32)
-        expect(described_class.encode(input3).bytesize).to eq(32)
-
-
-        input4 = ["one", 2, "three", ["four", 5, [6.0]]]
-        expect(described_class.field_value_size(input4)).to eq(69)
-        expect(described_class.encode(input4).bytesize).to eq(69)
-      end
-
-
-    end # TableValueEncoder
-  end # Protocol
-end # AMQ