amq-protocol 1.9.2 → 2.0.0

data/spec/amq/protocol/tx_spec.rb

@@ -11,8 +11,8 @@ module AMQ
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
             method_frame = Select.encode(channel)
-            method_frame.payload.should == "\000Z\000\n"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\000Z\000\n")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -27,8 +27,8 @@ module AMQ
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
             method_frame = Commit.encode(channel)
-            method_frame.payload.should == "\000Z\000\024"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\000Z\000\024")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -43,8 +43,8 @@ module AMQ
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
             method_frame = Rollback.encode(channel)
-            method_frame.payload.should == "\000Z\000\036"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\000Z\000\036")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end

data/spec/amq/protocol/value_decoder_spec.rb

@@ -12,27 +12,27 @@ module AMQ
         input1 = [1, 2, 3]
 
         value, offset = described_class.decode_array(TableValueEncoder.encode(input1), 1)
-        value.size.should == 3
-        value.first.should == 1
-        value.should == input1
+        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)
-        value.size.should == 3
-        value.first.should == "one"
-        value.should == input2
+        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)
-        value.size.should == 5
-        value.last.should == 5000000.0
-        value.should == input3
+        expect(value.size).to eq(5)
+        expect(value.last).to eq(5000000.0)
+        expect(value).to eq(input3)
       end
 
 
@@ -46,26 +46,26 @@ module AMQ
 
 
         value, offset = described_class.decode_array(data1, 1)
-        value.size.should == 2
-        value.first.should == Hash["one" => 2]
-        value.should == input1
+        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)
-        value.size.should == 3
-        value.last["three"]["four"].should == 5.0
-        value.should == input2
+        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, offset = described_class.decode_32bit_float(data, 1)
-        value.should == 10.0
+        value = described_class.decode_32bit_float(data, 1)[0]
+        expect(value).to eq(10.0)
       end
 
       context "8bit/byte decoding" do
@@ -80,7 +80,7 @@ module AMQ
 
         it "is capable of decoding byte values" do
           examples.each do |key, value|
-            described_class.decode_byte(value, 0).first.should == key
+            expect(described_class.decode_byte(value, 0).first).to eq(key)
           end
         end
       end

data/spec/amq/protocol/value_encoder_spec.rb

@@ -11,69 +11,69 @@ module AMQ
 
 
       it "calculates size of string field values" do
-        described_class.field_value_size("amqp").should == 9
-        described_class.encode("amqp").bytesize.should == 9
+        expect(described_class.field_value_size("amqp")).to eq(9)
+        expect(described_class.encode("amqp").bytesize).to eq(9)
 
-        described_class.field_value_size("amq-protocol").should == 17
-        described_class.encode("amq-protocol").bytesize.should == 17
+        expect(described_class.field_value_size("amq-protocol")).to eq(17)
+        expect(described_class.encode("amq-protocol").bytesize).to eq(17)
 
-        described_class.field_value_size("à bientôt").should == 16
-        described_class.encode("à bientôt").bytesize.should == 16
+        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
-        described_class.field_value_size(10).should == 5
-        described_class.encode(10).bytesize.should == 5
+        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
-        described_class.field_value_size(10.0).should == 9
-        described_class.encode(10.0).bytesize.should == 9
+        expect(described_class.field_value_size(10.0)).to eq(9)
+        expect(described_class.encode(10.0).bytesize).to eq(9)
 
-        described_class.field_value_size(120000.0).should == 9
-        described_class.encode(120000.0).bytesize.should == 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
-        described_class.encode(AMQ::Protocol::Float32Bit.new(10.0)).bytesize.should == 5
-        described_class.encode(AMQ::Protocol::Float32Bit.new(120000.0)).bytesize.should == 5
+        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
-        described_class.field_value_size(true).should == 2
-        described_class.encode(true).bytesize.should == 2
+        expect(described_class.field_value_size(true)).to eq(2)
+        expect(described_class.encode(true).bytesize).to eq(2)
 
-        described_class.field_value_size(false).should == 2
-        described_class.encode(false).bytesize.should == 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
-        described_class.field_value_size(nil).should == 1
-        described_class.encode(nil).bytesize.should == 1
+        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")
 
-        described_class.field_value_size(t).should == 9
-        described_class.encode(t).bytesize.should == 9
+        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" }
-        described_class.field_value_size(input1).should == 19
-        described_class.encode(input1).bytesize.should == 19
+        expect(described_class.field_value_size(input1)).to eq(19)
+        expect(described_class.encode(input1).bytesize).to eq(19)
 
 
         input2   = { "intval" => 1 }
-        described_class.field_value_size(input2).should == 17
-        described_class.encode(input2).bytesize.should == 17
+        expect(described_class.field_value_size(input2)).to eq(21)
+        expect(described_class.encode(input2).bytesize).to eq(21)
 
 
         input3   = { "intval" => 1, "key" => "value" }
-        described_class.field_value_size(input3).should == 31
-        described_class.encode(input3).bytesize.should == 31
+        expect(described_class.field_value_size(input3)).to eq(35)
+        expect(described_class.encode(input3).bytesize).to eq(35)
       end
 
 
@@ -87,7 +87,7 @@ module AMQ
               "rev"   => 1.0,
               "spec"  => {
                 "url"  => "http://bit.ly/hw2ELX",
-                "utf8" => one_point_eight? ? "à bientôt" : "à bientôt".force_encoding(::Encoding::ASCII_8BIT)
+                "utf8" => "à bientôt".force_encoding(::Encoding::ASCII_8BIT)
               }
             },
             "true"     => true,
@@ -96,9 +96,9 @@ module AMQ
           }
         }
 
-        described_class.field_value_size(input1).should == 162
+        expect(described_class.field_value_size(input1)).to eq(166)
         # puts(described_class.encode(input1).inspect)
-        described_class.encode(input1).bytesize.should == 162
+        expect(described_class.encode(input1).bytesize).to eq(166)
 
 
 
@@ -112,30 +112,30 @@ module AMQ
           "hashval"      => { "protocol" => "AMQP091", "true" => true, "false" => false, "nil" => nil }
         }
 
-        described_class.field_value_size(input2).should == 150
-        described_class.encode(input2).bytesize.should == 150
+        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]
 
-        described_class.field_value_size(input1).should == 20
-        described_class.encode(input1).bytesize.should == 20
+        expect(described_class.field_value_size(input1)).to eq(32)
+        expect(described_class.encode(input1).bytesize).to eq(32)
 
 
         input2 = ["one", "two", "three"]
-        described_class.field_value_size(input2).should == 31
-        described_class.encode(input2).bytesize.should == 31
+        expect(described_class.field_value_size(input2)).to eq(31)
+        expect(described_class.encode(input2).bytesize).to eq(31)
 
 
         input3 = ["one", 2, "three"]
-        described_class.field_value_size(input3).should == 28
-        described_class.encode(input3).bytesize.should == 28
+        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]]]
-        described_class.field_value_size(input4).should == 61
-        described_class.encode(input4).bytesize.should == 61
+        expect(described_class.field_value_size(input4)).to eq(69)
+        expect(described_class.encode(input4).bytesize).to eq(69)
       end
 
 

data/spec/amq/protocol_spec.rb

@@ -6,812 +6,812 @@ require File.expand_path('../../spec_helper', __FILE__)
 module AMQ
   describe Protocol do
     it "should have PROTOCOL_VERSION constant" do
-      Protocol::PROTOCOL_VERSION.should match(/^\d+\.\d+\.\d$/)
+      expect(Protocol::PROTOCOL_VERSION).to match(/^\d+\.\d+\.\d$/)
     end
 
     it "should have DEFAULT_PORT constant" do
-      Protocol::DEFAULT_PORT.should be_kind_of(Integer)
+      expect(Protocol::DEFAULT_PORT).to be_kind_of(Integer)
     end
 
     it "should have PREAMBLE constant" do
-      Protocol::PREAMBLE.should be_kind_of(String)
+      expect(Protocol::PREAMBLE).to be_kind_of(String)
     end
 
     describe Protocol::Error do
       it "should be an exception class" do
-        Protocol::Error.should < Exception
+        expect(Protocol::Error.ancestors).to include(Exception)
       end
     end
 
     describe Protocol::Connection do
       it "should be a subclass of Class" do
-        Protocol::Connection.superclass.should == Protocol::Class
+        expect(Protocol::Connection.superclass).to eq(Protocol::Class)
       end
 
       it "should have name equal to connection" do
-        Protocol::Connection.name.should eql("connection")
+        expect(Protocol::Connection.name).to eql("connection")
       end
 
       it "should have method id equal to 10" do
-        Protocol::Connection.method_id.should == 10
+        expect(Protocol::Connection.method_id).to eq(10)
       end
 
       describe Protocol::Connection::Start do
         it "should be a subclass of Method" do
-          Protocol::Connection::Start.superclass.should == Protocol::Method
+          expect(Protocol::Connection::Start.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.start" do
-          Protocol::Connection::Start.name.should eql("connection.start")
+          expect(Protocol::Connection::Start.name).to eql("connection.start")
         end
 
         it "should have method id equal to 10" do
-          Protocol::Connection::Start.method_id.should == 10
+          expect(Protocol::Connection::Start.method_id).to eq(10)
         end
       end
 
       describe Protocol::Connection::StartOk do
         it "should be a subclass of Method" do
-          Protocol::Connection::StartOk.superclass.should == Protocol::Method
+          expect(Protocol::Connection::StartOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.start-ok" do
-          Protocol::Connection::StartOk.name.should eql("connection.start-ok")
+          expect(Protocol::Connection::StartOk.name).to eql("connection.start-ok")
         end
 
         it "has method id equal to 11" do
-          Protocol::Connection::StartOk.method_id.should == 11
+          expect(Protocol::Connection::StartOk.method_id).to eq(11)
         end
       end
 
       describe Protocol::Connection::Secure do
         it "should be a subclass of Method" do
-          Protocol::Connection::Secure.superclass.should == Protocol::Method
+          expect(Protocol::Connection::Secure.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.secure" do
-          Protocol::Connection::Secure.name.should eql("connection.secure")
+          expect(Protocol::Connection::Secure.name).to eql("connection.secure")
         end
 
         it "has method id equal to 20" do
-          Protocol::Connection::Secure.method_id.should == 20
+          expect(Protocol::Connection::Secure.method_id).to eq(20)
         end
       end
 
       describe Protocol::Connection::SecureOk do
         it "should be a subclass of Method" do
-          Protocol::Connection::SecureOk.superclass.should == Protocol::Method
+          expect(Protocol::Connection::SecureOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.secure-ok" do
-          Protocol::Connection::SecureOk.name.should eql("connection.secure-ok")
+          expect(Protocol::Connection::SecureOk.name).to eql("connection.secure-ok")
         end
 
         it "has method id equal to 21" do
-          Protocol::Connection::SecureOk.method_id.should == 21
+          expect(Protocol::Connection::SecureOk.method_id).to eq(21)
         end
       end
 
       describe Protocol::Connection::Tune do
         it "should be a subclass of Method" do
-          Protocol::Connection::Tune.superclass.should == Protocol::Method
+          expect(Protocol::Connection::Tune.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.tune" do
-          Protocol::Connection::Tune.name.should eql("connection.tune")
+          expect(Protocol::Connection::Tune.name).to eql("connection.tune")
         end
 
         it "has method id equal to 30" do
-          Protocol::Connection::Tune.method_id.should == 30
+          expect(Protocol::Connection::Tune.method_id).to eq(30)
         end
       end
 
       describe Protocol::Connection::TuneOk do
         it "should be a subclass of Method" do
-          Protocol::Connection::TuneOk.superclass.should == Protocol::Method
+          expect(Protocol::Connection::TuneOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.tune-ok" do
-          Protocol::Connection::TuneOk.name.should eql("connection.tune-ok")
+          expect(Protocol::Connection::TuneOk.name).to eql("connection.tune-ok")
         end
 
         it "has method id equal to 31" do
-          Protocol::Connection::TuneOk.method_id.should == 31
+          expect(Protocol::Connection::TuneOk.method_id).to eq(31)
         end
 
         describe ".encode" do
           it do
             frame = Protocol::Connection::TuneOk.encode(0, 131072, 0)
-            frame.payload.should eql("\x00\n\x00\x1F\x00\x00\x00\x02\x00\x00\x00\x00")
+            expect(frame.payload).to eql("\x00\n\x00\x1F\x00\x00\x00\x02\x00\x00\x00\x00")
           end
         end
       end
 
       describe Protocol::Connection::Open do
         it "should be a subclass of Method" do
-          Protocol::Connection::Open.superclass.should == Protocol::Method
+          expect(Protocol::Connection::Open.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.open" do
-          Protocol::Connection::Open.name.should eql("connection.open")
+          expect(Protocol::Connection::Open.name).to eql("connection.open")
         end
 
         it "has method id equal to 40" do
-          Protocol::Connection::Open.method_id.should == 40
+          expect(Protocol::Connection::Open.method_id).to eq(40)
         end
       end
 
       describe Protocol::Connection::OpenOk do
         it "should be a subclass of Method" do
-          Protocol::Connection::OpenOk.superclass.should == Protocol::Method
+          expect(Protocol::Connection::OpenOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.open-ok" do
-          Protocol::Connection::OpenOk.name.should eql("connection.open-ok")
+          expect(Protocol::Connection::OpenOk.name).to eql("connection.open-ok")
         end
 
         it "has method id equal to 41" do
-          Protocol::Connection::OpenOk.method_id.should == 41
+          expect(Protocol::Connection::OpenOk.method_id).to eq(41)
         end
       end
 
       describe Protocol::Connection::Close do
         it "should be a subclass of Method" do
-          Protocol::Connection::Close.superclass.should == Protocol::Method
+          expect(Protocol::Connection::Close.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.close" do
-          Protocol::Connection::Close.name.should eql("connection.close")
+          expect(Protocol::Connection::Close.name).to eql("connection.close")
         end
 
         it "has method id equal to 50" do
-          Protocol::Connection::Close.method_id.should == 50
+          expect(Protocol::Connection::Close.method_id).to eq(50)
         end
       end
 
       describe Protocol::Connection::CloseOk do
         it "should be a subclass of Method" do
-          Protocol::Connection::CloseOk.superclass.should == Protocol::Method
+          expect(Protocol::Connection::CloseOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to connection.close-ok" do
-          Protocol::Connection::CloseOk.name.should eql("connection.close-ok")
+          expect(Protocol::Connection::CloseOk.name).to eql("connection.close-ok")
         end
 
         it "has method id equal to 51" do
-          Protocol::Connection::CloseOk.method_id.should == 51
+          expect(Protocol::Connection::CloseOk.method_id).to eq(51)
         end
       end
     end
 
     describe Protocol::Channel do
       it "should be a subclass of Class" do
-        Protocol::Channel.superclass.should == Protocol::Class
+        expect(Protocol::Channel.superclass).to eq(Protocol::Class)
       end
 
       it "should have name equal to channel" do
-        Protocol::Channel.name.should eql("channel")
+        expect(Protocol::Channel.name).to eql("channel")
       end
 
       it "has method id equal to 20" do
-        Protocol::Channel.method_id.should == 20
+        expect(Protocol::Channel.method_id).to eq(20)
       end
 
       describe Protocol::Channel::Open do
         it "should be a subclass of Method" do
-          Protocol::Channel::Open.superclass.should == Protocol::Method
+          expect(Protocol::Channel::Open.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to channel.open" do
-          Protocol::Channel::Open.name.should eql("channel.open")
+          expect(Protocol::Channel::Open.name).to eql("channel.open")
         end
 
         it "has method id equal to 10" do
-          Protocol::Channel::Open.method_id.should == 10
+          expect(Protocol::Channel::Open.method_id).to eq(10)
         end
       end
 
       describe Protocol::Channel::OpenOk do
         it "should be a subclass of Method" do
-          Protocol::Channel::OpenOk.superclass.should == Protocol::Method
+          expect(Protocol::Channel::OpenOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to channel.open-ok" do
-          Protocol::Channel::OpenOk.name.should eql("channel.open-ok")
+          expect(Protocol::Channel::OpenOk.name).to eql("channel.open-ok")
         end
 
         it "has method id equal to 11" do
-          Protocol::Channel::OpenOk.method_id.should == 11
+          expect(Protocol::Channel::OpenOk.method_id).to eq(11)
         end
       end
 
       describe Protocol::Channel::Flow do
         it "should be a subclass of Method" do
-          Protocol::Channel::Flow.superclass.should == Protocol::Method
+          expect(Protocol::Channel::Flow.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to channel.flow" do
-          Protocol::Channel::Flow.name.should eql("channel.flow")
+          expect(Protocol::Channel::Flow.name).to eql("channel.flow")
         end
 
         it "has method id equal to 20" do
-          Protocol::Channel::Flow.method_id.should == 20
+          expect(Protocol::Channel::Flow.method_id).to eq(20)
         end
       end
 
       describe Protocol::Channel::FlowOk do
         it "should be a subclass of Method" do
-          Protocol::Channel::FlowOk.superclass.should == Protocol::Method
+          expect(Protocol::Channel::FlowOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to channel.flow-ok" do
-          Protocol::Channel::FlowOk.name.should eql("channel.flow-ok")
+          expect(Protocol::Channel::FlowOk.name).to eql("channel.flow-ok")
         end
 
         it "has method id equal to 21" do
-          Protocol::Channel::FlowOk.method_id.should == 21
+          expect(Protocol::Channel::FlowOk.method_id).to eq(21)
         end
       end
 
       describe Protocol::Channel::Close do
         it "should be a subclass of Method" do
-          Protocol::Channel::Close.superclass.should == Protocol::Method
+          expect(Protocol::Channel::Close.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to channel.close" do
-          Protocol::Channel::Close.name.should eql("channel.close")
+          expect(Protocol::Channel::Close.name).to eql("channel.close")
         end
 
         it "has method id equal to 40" do
-          Protocol::Channel::Close.method_id.should == 40
+          expect(Protocol::Channel::Close.method_id).to eq(40)
         end
       end
 
       describe Protocol::Channel::CloseOk do
         it "should be a subclass of Method" do
-          Protocol::Channel::CloseOk.superclass.should == Protocol::Method
+          expect(Protocol::Channel::CloseOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to channel.close-ok" do
-          Protocol::Channel::CloseOk.name.should eql("channel.close-ok")
+          expect(Protocol::Channel::CloseOk.name).to eql("channel.close-ok")
         end
 
         it "has method id equal to 41" do
-          Protocol::Channel::CloseOk.method_id.should == 41
+          expect(Protocol::Channel::CloseOk.method_id).to eq(41)
         end
       end
     end
 
     describe Protocol::Exchange do
       it "should be a subclass of Class" do
-        Protocol::Exchange.superclass.should == Protocol::Class
+        expect(Protocol::Exchange.superclass).to eq(Protocol::Class)
       end
 
       it "should have name equal to exchange" do
-        Protocol::Exchange.name.should eql("exchange")
+        expect(Protocol::Exchange.name).to eql("exchange")
       end
 
       it "has method id equal to 40" do
-        Protocol::Exchange.method_id.should == 40
+        expect(Protocol::Exchange.method_id).to eq(40)
       end
 
       describe Protocol::Exchange::Declare do
         it "should be a subclass of Method" do
-          Protocol::Exchange::Declare.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::Declare.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.declare" do
-          Protocol::Exchange::Declare.name.should eql("exchange.declare")
+          expect(Protocol::Exchange::Declare.name).to eql("exchange.declare")
         end
 
         it "has method id equal to 10" do
-          Protocol::Exchange::Declare.method_id.should == 10
+          expect(Protocol::Exchange::Declare.method_id).to eq(10)
         end
       end
 
       describe Protocol::Exchange::DeclareOk do
         it "should be a subclass of Method" do
-          Protocol::Exchange::DeclareOk.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::DeclareOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.declare-ok" do
-          Protocol::Exchange::DeclareOk.name.should eql("exchange.declare-ok")
+          expect(Protocol::Exchange::DeclareOk.name).to eql("exchange.declare-ok")
         end
 
         it "has method id equal to 11" do
-          Protocol::Exchange::DeclareOk.method_id.should == 11
+          expect(Protocol::Exchange::DeclareOk.method_id).to eq(11)
         end
       end
 
       describe Protocol::Exchange::Delete do
         it "should be a subclass of Method" do
-          Protocol::Exchange::Delete.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::Delete.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.delete" do
-          Protocol::Exchange::Delete.name.should eql("exchange.delete")
+          expect(Protocol::Exchange::Delete.name).to eql("exchange.delete")
         end
 
         it "has method id equal to 20" do
-          Protocol::Exchange::Delete.method_id.should == 20
+          expect(Protocol::Exchange::Delete.method_id).to eq(20)
         end
       end
 
       describe Protocol::Exchange::DeleteOk do
         it "should be a subclass of Method" do
-          Protocol::Exchange::DeleteOk.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::DeleteOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.delete-ok" do
-          Protocol::Exchange::DeleteOk.name.should eql("exchange.delete-ok")
+          expect(Protocol::Exchange::DeleteOk.name).to eql("exchange.delete-ok")
         end
 
         it "has method id equal to 21" do
-          Protocol::Exchange::DeleteOk.method_id.should == 21
+          expect(Protocol::Exchange::DeleteOk.method_id).to eq(21)
         end
       end
 
       describe Protocol::Exchange::Bind do
         it "should be a subclass of Method" do
-          Protocol::Exchange::Bind.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::Bind.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.bind" do
-          Protocol::Exchange::Bind.name.should eql("exchange.bind")
+          expect(Protocol::Exchange::Bind.name).to eql("exchange.bind")
         end
 
         it "has method id equal to 30" do
-          Protocol::Exchange::Bind.method_id.should == 30
+          expect(Protocol::Exchange::Bind.method_id).to eq(30)
         end
       end
 
       describe Protocol::Exchange::BindOk do
         it "should be a subclass of Method" do
-          Protocol::Exchange::BindOk.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::BindOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.bind-ok" do
-          Protocol::Exchange::BindOk.name.should eql("exchange.bind-ok")
+          expect(Protocol::Exchange::BindOk.name).to eql("exchange.bind-ok")
         end
 
         it "has method id equal to 31" do
-          Protocol::Exchange::BindOk.method_id.should == 31
+          expect(Protocol::Exchange::BindOk.method_id).to eq(31)
         end
       end
 
       describe Protocol::Exchange::Unbind do
         it "should be a subclass of Method" do
-          Protocol::Exchange::Unbind.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::Unbind.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.unbind" do
-          Protocol::Exchange::Unbind.name.should eql("exchange.unbind")
+          expect(Protocol::Exchange::Unbind.name).to eql("exchange.unbind")
         end
 
         it "has method id equal to 40" do
-          Protocol::Exchange::Unbind.method_id.should == 40
+          expect(Protocol::Exchange::Unbind.method_id).to eq(40)
         end
       end
 
       describe Protocol::Exchange::UnbindOk do
         it "should be a subclass of Method" do
-          Protocol::Exchange::UnbindOk.superclass.should == Protocol::Method
+          expect(Protocol::Exchange::UnbindOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to exchange.unbind-ok" do
-          Protocol::Exchange::UnbindOk.name.should eql("exchange.unbind-ok")
+          expect(Protocol::Exchange::UnbindOk.name).to eql("exchange.unbind-ok")
         end
 
         it "has method id equal to 51" do
-          Protocol::Exchange::UnbindOk.method_id.should == 51
+          expect(Protocol::Exchange::UnbindOk.method_id).to eq(51)
         end
       end
     end
 
     describe Protocol::Queue do
       it "should be a subclass of Class" do
-        Protocol::Queue.superclass.should == Protocol::Class
+        expect(Protocol::Queue.superclass).to eq(Protocol::Class)
       end
 
       it "should have name equal to queue" do
-        Protocol::Queue.name.should eql("queue")
+        expect(Protocol::Queue.name).to eql("queue")
       end
 
       it "has method id equal to 50" do
-        Protocol::Queue.method_id.should == 50
+        expect(Protocol::Queue.method_id).to eq(50)
       end
 
       describe Protocol::Queue::Declare do
         it "should be a subclass of Method" do
-          Protocol::Queue::Declare.superclass.should == Protocol::Method
+          expect(Protocol::Queue::Declare.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.declare" do
-          Protocol::Queue::Declare.name.should eql("queue.declare")
+          expect(Protocol::Queue::Declare.name).to eql("queue.declare")
         end
 
         it "has method id equal to 10" do
-          Protocol::Queue::Declare.method_id.should == 10
+          expect(Protocol::Queue::Declare.method_id).to eq(10)
         end
       end
 
       describe Protocol::Queue::DeclareOk do
         it "should be a subclass of Method" do
-          Protocol::Queue::DeclareOk.superclass.should == Protocol::Method
+          expect(Protocol::Queue::DeclareOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.declare-ok" do
-          Protocol::Queue::DeclareOk.name.should eql("queue.declare-ok")
+          expect(Protocol::Queue::DeclareOk.name).to eql("queue.declare-ok")
         end
 
         it "has method id equal to 11" do
-          Protocol::Queue::DeclareOk.method_id.should == 11
+          expect(Protocol::Queue::DeclareOk.method_id).to eq(11)
         end
       end
 
       describe Protocol::Queue::Bind do
         it "should be a subclass of Method" do
-          Protocol::Queue::Bind.superclass.should == Protocol::Method
+          expect(Protocol::Queue::Bind.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.bind" do
-          Protocol::Queue::Bind.name.should eql("queue.bind")
+          expect(Protocol::Queue::Bind.name).to eql("queue.bind")
         end
 
         it "has method id equal to 20" do
-          Protocol::Queue::Bind.method_id.should == 20
+          expect(Protocol::Queue::Bind.method_id).to eq(20)
         end
       end
 
       describe Protocol::Queue::BindOk do
         it "should be a subclass of Method" do
-          Protocol::Queue::BindOk.superclass.should == Protocol::Method
+          expect(Protocol::Queue::BindOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.bind-ok" do
-          Protocol::Queue::BindOk.name.should eql("queue.bind-ok")
+          expect(Protocol::Queue::BindOk.name).to eql("queue.bind-ok")
         end
 
         it "has method id equal to 21" do
-          Protocol::Queue::BindOk.method_id.should == 21
+          expect(Protocol::Queue::BindOk.method_id).to eq(21)
         end
       end
 
       describe Protocol::Queue::Purge do
         it "should be a subclass of Method" do
-          Protocol::Queue::Purge.superclass.should == Protocol::Method
+          expect(Protocol::Queue::Purge.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.purge" do
-          Protocol::Queue::Purge.name.should eql("queue.purge")
+          expect(Protocol::Queue::Purge.name).to eql("queue.purge")
         end
 
         it "has method id equal to 30" do
-          Protocol::Queue::Purge.method_id.should == 30
+          expect(Protocol::Queue::Purge.method_id).to eq(30)
         end
       end
 
       describe Protocol::Queue::PurgeOk do
         it "should be a subclass of Method" do
-          Protocol::Queue::PurgeOk.superclass.should == Protocol::Method
+          expect(Protocol::Queue::PurgeOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.purge-ok" do
-          Protocol::Queue::PurgeOk.name.should eql("queue.purge-ok")
+          expect(Protocol::Queue::PurgeOk.name).to eql("queue.purge-ok")
         end
 
         it "has method id equal to 31" do
-          Protocol::Queue::PurgeOk.method_id.should == 31
+          expect(Protocol::Queue::PurgeOk.method_id).to eq(31)
         end
       end
 
       describe Protocol::Queue::Delete do
         it "should be a subclass of Method" do
-          Protocol::Queue::Delete.superclass.should == Protocol::Method
+          expect(Protocol::Queue::Delete.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.delete" do
-          Protocol::Queue::Delete.name.should eql("queue.delete")
+          expect(Protocol::Queue::Delete.name).to eql("queue.delete")
         end
 
         it "has method id equal to 40" do
-          Protocol::Queue::Delete.method_id.should == 40
+          expect(Protocol::Queue::Delete.method_id).to eq(40)
         end
       end
 
       describe Protocol::Queue::DeleteOk do
         it "should be a subclass of Method" do
-          Protocol::Queue::DeleteOk.superclass.should == Protocol::Method
+          expect(Protocol::Queue::DeleteOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.delete-ok" do
-          Protocol::Queue::DeleteOk.name.should eql("queue.delete-ok")
+          expect(Protocol::Queue::DeleteOk.name).to eql("queue.delete-ok")
         end
 
         it "has method id equal to 41" do
-          Protocol::Queue::DeleteOk.method_id.should == 41
+          expect(Protocol::Queue::DeleteOk.method_id).to eq(41)
         end
       end
 
       describe Protocol::Queue::Unbind do
         it "should be a subclass of Method" do
-          Protocol::Queue::Unbind.superclass.should == Protocol::Method
+          expect(Protocol::Queue::Unbind.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.unbind" do
-          Protocol::Queue::Unbind.name.should eql("queue.unbind")
+          expect(Protocol::Queue::Unbind.name).to eql("queue.unbind")
         end
 
         it "has method id equal to 50" do
-          Protocol::Queue::Unbind.method_id.should == 50
+          expect(Protocol::Queue::Unbind.method_id).to eq(50)
         end
       end
 
       describe Protocol::Queue::UnbindOk do
         it "should be a subclass of Method" do
-          Protocol::Queue::UnbindOk.superclass.should == Protocol::Method
+          expect(Protocol::Queue::UnbindOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to queue.unbind-ok" do
-          Protocol::Queue::UnbindOk.name.should eql("queue.unbind-ok")
+          expect(Protocol::Queue::UnbindOk.name).to eql("queue.unbind-ok")
         end
 
         it "has method id equal to 51" do
-          Protocol::Queue::UnbindOk.method_id.should == 51
+          expect(Protocol::Queue::UnbindOk.method_id).to eq(51)
         end
       end
     end
 
     describe Protocol::Basic do
       it "should be a subclass of Class" do
-        Protocol::Basic.superclass.should == Protocol::Class
+        expect(Protocol::Basic.superclass).to eq(Protocol::Class)
       end
 
       it "should have name equal to basic" do
-        Protocol::Basic.name.should eql("basic")
+        expect(Protocol::Basic.name).to eql("basic")
       end
 
       it "has method id equal to 60" do
-        Protocol::Basic.method_id.should == 60
+        expect(Protocol::Basic.method_id).to eq(60)
       end
 
       describe Protocol::Basic::Qos do
         it "should be a subclass of Method" do
-          Protocol::Basic::Qos.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Qos.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.qos" do
-          Protocol::Basic::Qos.name.should eql("basic.qos")
+          expect(Protocol::Basic::Qos.name).to eql("basic.qos")
         end
 
         it "has method id equal to 10" do
-          Protocol::Basic::Qos.method_id.should == 10
+          expect(Protocol::Basic::Qos.method_id).to eq(10)
         end
       end
 
       describe Protocol::Basic::QosOk do
         it "should be a subclass of Method" do
-          Protocol::Basic::QosOk.superclass.should == Protocol::Method
+          expect(Protocol::Basic::QosOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.qos-ok" do
-          Protocol::Basic::QosOk.name.should eql("basic.qos-ok")
+          expect(Protocol::Basic::QosOk.name).to eql("basic.qos-ok")
         end
 
         it "has method id equal to 11" do
-          Protocol::Basic::QosOk.method_id.should == 11
+          expect(Protocol::Basic::QosOk.method_id).to eq(11)
         end
       end
 
       describe Protocol::Basic::Consume do
         it "should be a subclass of Method" do
-          Protocol::Basic::Consume.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Consume.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.consume" do
-          Protocol::Basic::Consume.name.should eql("basic.consume")
+          expect(Protocol::Basic::Consume.name).to eql("basic.consume")
         end
 
         it "has method id equal to 20" do
-          Protocol::Basic::Consume.method_id.should == 20
+          expect(Protocol::Basic::Consume.method_id).to eq(20)
         end
       end
 
       describe Protocol::Basic::ConsumeOk do
         it "should be a subclass of Method" do
-          Protocol::Basic::ConsumeOk.superclass.should == Protocol::Method
+          expect(Protocol::Basic::ConsumeOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.consume-ok" do
-          Protocol::Basic::ConsumeOk.name.should eql("basic.consume-ok")
+          expect(Protocol::Basic::ConsumeOk.name).to eql("basic.consume-ok")
         end
 
         it "has method id equal to 21" do
-          Protocol::Basic::ConsumeOk.method_id.should == 21
+          expect(Protocol::Basic::ConsumeOk.method_id).to eq(21)
         end
       end
 
       describe Protocol::Basic::Cancel do
         it "should be a subclass of Method" do
-          Protocol::Basic::Cancel.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Cancel.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.cancel" do
-          Protocol::Basic::Cancel.name.should eql("basic.cancel")
+          expect(Protocol::Basic::Cancel.name).to eql("basic.cancel")
         end
 
         it "has method id equal to 30" do
-          Protocol::Basic::Cancel.method_id.should == 30
+          expect(Protocol::Basic::Cancel.method_id).to eq(30)
         end
       end
 
       describe Protocol::Basic::CancelOk do
         it "should be a subclass of Method" do
-          Protocol::Basic::CancelOk.superclass.should == Protocol::Method
+          expect(Protocol::Basic::CancelOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.cancel-ok" do
-          Protocol::Basic::CancelOk.name.should eql("basic.cancel-ok")
+          expect(Protocol::Basic::CancelOk.name).to eql("basic.cancel-ok")
         end
 
         it "has method id equal to 31" do
-          Protocol::Basic::CancelOk.method_id.should == 31
+          expect(Protocol::Basic::CancelOk.method_id).to eq(31)
         end
       end
 
       describe Protocol::Basic::Publish do
         it "should be a subclass of Method" do
-          Protocol::Basic::Publish.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Publish.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.publish" do
-          Protocol::Basic::Publish.name.should eql("basic.publish")
+          expect(Protocol::Basic::Publish.name).to eql("basic.publish")
         end
 
         it "has method id equal to 40" do
-          Protocol::Basic::Publish.method_id.should == 40
+          expect(Protocol::Basic::Publish.method_id).to eq(40)
         end
       end
 
       describe Protocol::Basic::Return do
         it "should be a subclass of Method" do
-          Protocol::Basic::Return.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Return.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.return" do
-          Protocol::Basic::Return.name.should eql("basic.return")
+          expect(Protocol::Basic::Return.name).to eql("basic.return")
         end
 
         it "has method id equal to 50" do
-          Protocol::Basic::Return.method_id.should == 50
+          expect(Protocol::Basic::Return.method_id).to eq(50)
         end
       end
 
       describe Protocol::Basic::Deliver do
         it "should be a subclass of Method" do
-          Protocol::Basic::Deliver.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Deliver.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.deliver" do
-          Protocol::Basic::Deliver.name.should eql("basic.deliver")
+          expect(Protocol::Basic::Deliver.name).to eql("basic.deliver")
         end
 
         it "has method id equal to 60" do
-          Protocol::Basic::Deliver.method_id.should == 60
+          expect(Protocol::Basic::Deliver.method_id).to eq(60)
         end
       end
 
       describe Protocol::Basic::Get do
         it "should be a subclass of Method" do
-          Protocol::Basic::Get.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Get.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.get" do
-          Protocol::Basic::Get.name.should eql("basic.get")
+          expect(Protocol::Basic::Get.name).to eql("basic.get")
         end
 
         it "has method id equal to 70" do
-          Protocol::Basic::Get.method_id.should == 70
+          expect(Protocol::Basic::Get.method_id).to eq(70)
         end
       end
 
       describe Protocol::Basic::GetOk do
         it "should be a subclass of Method" do
-          Protocol::Basic::GetOk.superclass.should == Protocol::Method
+          expect(Protocol::Basic::GetOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.get-ok" do
-          Protocol::Basic::GetOk.name.should eql("basic.get-ok")
+          expect(Protocol::Basic::GetOk.name).to eql("basic.get-ok")
         end
 
         it "has method id equal to 71" do
-          Protocol::Basic::GetOk.method_id.should == 71
+          expect(Protocol::Basic::GetOk.method_id).to eq(71)
         end
       end
 
       describe Protocol::Basic::GetEmpty do
         it "should be a subclass of Method" do
-          Protocol::Basic::GetEmpty.superclass.should == Protocol::Method
+          expect(Protocol::Basic::GetEmpty.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.get-empty" do
-          Protocol::Basic::GetEmpty.name.should eql("basic.get-empty")
+          expect(Protocol::Basic::GetEmpty.name).to eql("basic.get-empty")
         end
 
         it "has method id equal to 72" do
-          Protocol::Basic::GetEmpty.method_id.should == 72
+          expect(Protocol::Basic::GetEmpty.method_id).to eq(72)
         end
       end
 
       describe Protocol::Basic::Ack do
         it "should be a subclass of Method" do
-          Protocol::Basic::Ack.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Ack.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.ack" do
-          Protocol::Basic::Ack.name.should eql("basic.ack")
+          expect(Protocol::Basic::Ack.name).to eql("basic.ack")
         end
 
         it "has method id equal to 80" do
-          Protocol::Basic::Ack.method_id.should == 80
+          expect(Protocol::Basic::Ack.method_id).to eq(80)
         end
       end
 
       describe Protocol::Basic::Reject do
         it "should be a subclass of Method" do
-          Protocol::Basic::Reject.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Reject.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.reject" do
-          Protocol::Basic::Reject.name.should eql("basic.reject")
+          expect(Protocol::Basic::Reject.name).to eql("basic.reject")
         end
 
         it "has method id equal to 90" do
-          Protocol::Basic::Reject.method_id.should == 90
+          expect(Protocol::Basic::Reject.method_id).to eq(90)
         end
       end
 
       describe Protocol::Basic::RecoverAsync do
         it "should be a subclass of Method" do
-          Protocol::Basic::RecoverAsync.superclass.should == Protocol::Method
+          expect(Protocol::Basic::RecoverAsync.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.recover-async" do
-          Protocol::Basic::RecoverAsync.name.should eql("basic.recover-async")
+          expect(Protocol::Basic::RecoverAsync.name).to eql("basic.recover-async")
         end
 
         it "has method id equal to 100" do
-          Protocol::Basic::RecoverAsync.method_id.should == 100
+          expect(Protocol::Basic::RecoverAsync.method_id).to eq(100)
         end
       end
 
       describe Protocol::Basic::Recover do
         it "should be a subclass of Method" do
-          Protocol::Basic::Recover.superclass.should == Protocol::Method
+          expect(Protocol::Basic::Recover.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.recover" do
-          Protocol::Basic::Recover.name.should eql("basic.recover")
+          expect(Protocol::Basic::Recover.name).to eql("basic.recover")
         end
 
         it "has method id equal to 110" do
-          Protocol::Basic::Recover.method_id.should == 110
+          expect(Protocol::Basic::Recover.method_id).to eq(110)
         end
       end
 
       describe Protocol::Basic::RecoverOk do
         it "should be a subclass of Method" do
-          Protocol::Basic::RecoverOk.superclass.should == Protocol::Method
+          expect(Protocol::Basic::RecoverOk.superclass).to eq(Protocol::Method)
         end
 
         it "should have method name equal to basic.recover-ok" do
-          Protocol::Basic::RecoverOk.name.should eql("basic.recover-ok")
+          expect(Protocol::Basic::RecoverOk.name).to eql("basic.recover-ok")
         end
 
         it "has method id equal to 111" do
-          Protocol::Basic::RecoverOk.method_id.should == 111
+          expect(Protocol::Basic::RecoverOk.method_id).to eq(111)
         end
       end
     end
   end
-end
+end