amq-protocol 2.4.0 → 2.5.1

data/spec/amq/protocol/table_spec.rb

@@ -1,291 +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
-
-      describe ".length" do
-        it "returns the table length from binary data" do
-          encoded = Table.encode({"test" => 1})
-          expect(Table.length(encoded)).to eq(14)
-        end
-
-        it "returns 0 for empty table" do
-          encoded = Table.encode({})
-          expect(Table.length(encoded)).to eq(0)
-        end
-      end
-
-      describe ".hash_size" do
-        it "calculates size for simple hash" do
-          size = Table.hash_size({"key" => "value"})
-          expect(size).to be > 0
-        end
-
-        it "returns 0 for empty hash" do
-          size = Table.hash_size({})
-          expect(size).to eq(0)
-        end
-      end
-
-      describe "Table::InvalidTableError" do
-        it "formats error message with key and value" do
-          error = Table::InvalidTableError.new("mykey", Object.new)
-          expect(error.message).to include("mykey")
-          expect(error.message).to include("Object")
-        end
-      end
-    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,183 +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
-
-      describe ".decode_string" do
-        it "decodes string values" do
-          # 4 bytes length + string content
-          data = "\x00\x00\x00\x05hello"
-          value, offset = described_class.decode_string(data, 0)
-          expect(value).to eq("hello")
-          expect(offset).to eq(9)
-        end
-      end
-
-      describe ".decode_integer" do
-        it "decodes 32-bit unsigned integers" do
-          data = "\x00\x00\x00\x0A"
-          value, offset = described_class.decode_integer(data, 0)
-          expect(value).to eq(10)
-          expect(offset).to eq(4)
-        end
-      end
-
-      describe ".decode_long" do
-        it "decodes 64-bit signed integers" do
-          data = "\x00\x00\x00\x00\x00\x00\x00\x0A"
-          value, offset = described_class.decode_long(data, 0)
-          expect(value).to eq(10)
-          expect(offset).to eq(8)
-        end
-      end
-
-      describe ".decode_time" do
-        it "decodes timestamp values" do
-          timestamp = Time.now.to_i
-          data = [timestamp].pack('Q>')
-          value, offset = described_class.decode_time(data, 0)
-          expect(value.to_i).to eq(timestamp)
-          expect(offset).to eq(8)
-        end
-      end
-
-      describe ".decode_boolean" do
-        it "decodes true" do
-          value, offset = described_class.decode_boolean("\x01", 0)
-          expect(value).to eq(true)
-          expect(offset).to eq(1)
-        end
-
-        it "decodes false" do
-          value, offset = described_class.decode_boolean("\x00", 0)
-          expect(value).to eq(false)
-          expect(offset).to eq(1)
-        end
-      end
-
-      describe ".decode_64bit_float" do
-        it "decodes 64-bit floats" do
-          data = [3.14159].pack('G')
-          value, offset = described_class.decode_64bit_float(data, 0)
-          expect(value).to be_within(0.00001).of(3.14159)
-          expect(offset).to eq(8)
-        end
-      end
-
-      describe ".decode_value_type" do
-        it "returns the type byte and incremented offset" do
-          data = "Shello"
-          type, offset = described_class.decode_value_type(data, 0)
-          expect(type).to eq("S")
-          expect(offset).to eq(1)
-        end
-      end
-
-      describe ".decode_short" do
-        it "decodes 16-bit signed integers" do
-          data = "\x06\x8D"
-          value, offset = described_class.decode_short(data, 0)
-          expect(value).to eq(1677)
-          expect(offset).to eq(2)
-        end
-      end
-
-      describe ".decode_big_decimal" do
-        it "decodes BigDecimal values" do
-          # Scale 2, raw value 100 = 1.00
-          data = "\x02\x00\x00\x00\x64"
-          value, offset = described_class.decode_big_decimal(data, 0)
-          expect(value).to be_a(BigDecimal)
-          expect(offset).to eq(5)
-        end
-      end
-
-      describe ".decode_hash" do
-        it "decodes nested hash values" do
-          encoded = AMQ::Protocol::Table.encode({"nested" => "value"})
-          value, _offset = described_class.decode_hash(encoded, 0)
-          expect(value).to eq({"nested" => "value"})
-        end
-      end
-    end
-  end
-end

data/spec/amq/protocol/value_encoder_spec.rb

@@ -1,161 +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
-
-      it "encodes symbols as strings" do
-        encoded = described_class.encode(:test_symbol)
-        expect(encoded).to start_with("S")
-        expect(encoded).to include("test_symbol")
-      end
-
-      it "encodes BigDecimal values" do
-        bd = BigDecimal("123.45")
-        encoded = described_class.encode(bd)
-        expect(encoded).to start_with("D")
-      end
-
-      it "encodes BigDecimal with zero exponent" do
-        bd = BigDecimal("100")
-        encoded = described_class.encode(bd)
-        expect(encoded).to start_with("D")
-      end
-
-      it "raises ArgumentError for unsupported types" do
-        expect { described_class.encode(Object.new) }.to raise_error(ArgumentError)
-      end
-
-    end # TableValueEncoder
-  end # Protocol
-end # AMQ