amq-protocol 1.9.2 → 2.0.0

data/spec/amq/pack_spec.rb

@@ -14,7 +14,7 @@ module AMQ
 
       it "unpacks signed integers from a string to a number" do
         examples_16bit.each do |key, value|
-          described_class.unpack_int16_big_endian(value)[0].should == key
+          expect(described_class.unpack_int16_big_endian(value)[0]).to eq(key)
         end
       end
     end
@@ -37,13 +37,13 @@ module AMQ
 
       it "packs integers into big-endian string" do
         examples.each do |key, value|
-          described_class.pack_uint64_big_endian(key).should == value
+          expect(described_class.pack_uint64_big_endian(key)).to eq(value)
         end
       end
 
       it "should unpack string representation into integer" do
         examples.each do |key, value|
-          described_class.unpack_uint64_big_endian(value)[0].should == key
+          expect(described_class.unpack_uint64_big_endian(value)[0]).to eq(key)
         end
       end
 
@@ -59,13 +59,13 @@ module AMQ
 
           it "packs integers into big-endian string" do
             examples.each do |key, value|
-              described_class.pack_uint64_big_endian(key).should == value
+              expect(described_class.pack_uint64_big_endian(key)).to eq(value)
             end
           end
 
           it "should unpack string representation into integer" do
             examples.each do |key, value|
-              described_class.unpack_uint64_big_endian(value)[0].should == key
+              expect(described_class.unpack_uint64_big_endian(value)[0]).to eq(key)
             end
           end
         end

data/spec/amq/protocol/basic_spec.rb

@@ -8,58 +8,58 @@ module AMQ
     describe Basic do
       describe '.encode_timestamp' do
         it 'encodes the timestamp as a 64 byte big endian integer' do
-          Basic.encode_timestamp(12345).last.should == "\x00\x00\x00\x00\x00\x0009"
+          expect(Basic.encode_timestamp(12345).last).to eq("\x00\x00\x00\x00\x00\x0009")
         end
       end
       
       # describe '.decode_timestamp' do
       #   it 'decodes the timestamp from a 64 byte big endian integer and returns a Time object' do
-      #     Basic.decode_timestamp("\x00\x00\x00\x00\x00\x0009").should == Time.at(12345)
+      #     expect(Basic.decode_timestamp("\x00\x00\x00\x00\x00\x0009")).to eq(Time.at(12345))
       #   end
       # end
       
       describe '.encode_headers' do
         it 'encodes the headers as a table' do
-          Basic.encode_headers(:hello => 'world').last.should == "\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world"
+          expect(Basic.encode_headers(:hello => 'world').last).to eq("\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world")
         end
       end
       
       # describe '.decode_headers' do
       #   it 'decodes the headers from a table' do
-      #     Basic.decode_headers("\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world").should == {'hello' => 'world'}
+      #     expect(Basic.decode_headers("\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world")).to eq({'hello' => 'world'})
       #   end
       # end
       
       describe '.encode_properties' do
         it 'packs the parameters into a byte array using the other encode_* methods' do
           result = Basic.encode_properties(10, {:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream'})
-          result.should == "\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x98\x00\x18application/octet-stream\x02\x00"
+          expect(result).to eq("\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x98\x00\x18application/octet-stream\x02\x00")
         end
       end
       
       describe '.decode_properties' do
         it 'unpacks the properties from a byte array using the decode_* methods' do
           result = Basic.decode_properties("\x98@\x18application/octet-stream\x02\x00\x00\x00\x00\x00\x00\x00\x00{")
-          result.should == {:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream', :timestamp => Time.at(123)}
+          expect(result).to eq({:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream', :timestamp => Time.at(123)})
         end
 
         it 'unpacks the properties from a byte array using the decode_* methods, including a table' do
           result = Basic.decode_properties("\xB8@\x18application/octet-stream\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world\x02\x00\x00\x00\x00\x00\x00\x00\x00{")
-          result.should == {:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream', :timestamp => Time.at(123), :headers => {'hello' => 'world'}}
+          expect(result).to eq({:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream', :timestamp => Time.at(123), :headers => {'hello' => 'world'}})
         end
       end
       
       %w(content_type content_encoding correlation_id reply_to expiration message_id type user_id app_id cluster_id).each do |method|
         describe ".encode_#{method}" do
           it 'encodes the parameter as a Pascal string' do
-            Basic.send("encode_#{method}", 'hello world').last.should == "\x0bhello world"
+            expect(Basic.send("encode_#{method}", 'hello world').last).to eq("\x0bhello world")
           end
         end
 
         # describe ".decode_#{method}" do
         #   it 'returns the string' do
         #     # the length has been stripped in .decode_properties
-        #     Basic.send("decode_#{method}", 'hello world').should == 'hello world'
+        #     expect(Basic.send("decode_#{method}", 'hello world')).to eq('hello world')
         #   end
         # end
       end
@@ -67,13 +67,13 @@ module AMQ
       %w(delivery_mode priority).each do |method|
         describe ".encode_#{method}" do
           it 'encodes the parameter as a char' do
-            Basic.send("encode_#{method}", 10).last.should == "\x0a"
+            expect(Basic.send("encode_#{method}", 10).last).to eq("\x0a")
           end
         end
 
         # describe ".decode_#{method}" do
         #   it 'decodes the value from a char' do
-        #     Basic.send("decode_#{method}", "\x10").should == 16
+        #     expect(Basic.send("decode_#{method}", "\x10")).to eq(16)
         #   end
         # end
       end
@@ -88,8 +88,8 @@ module AMQ
             prefetch_count = 5
             global = false
             method_frame = Qos.encode(channel, prefetch_size, prefetch_count, global)
-            method_frame.payload.should == "\x00<\x00\n\x00\x00\x00\x03\x00\x05\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00\n\x00\x00\x00\x03\x00\x05\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -111,8 +111,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Consume.encode(channel, queue, consumer_tag, no_local, no_ack, exclusive, nowait, arguments)
-            method_frame.payload.should == "\x00<\x00\x14\x00\x00\x03foo\x02me\x04\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00\x14\x00\x00\x03foo\x02me\x04\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -123,7 +123,7 @@ module AMQ
             ConsumeOk.decode("\x03foo")
           end
           
-          its(:consumer_tag) { should == 'foo' }
+          its(:consumer_tag) { should eq('foo') }
         end
       end
 
@@ -134,8 +134,8 @@ module AMQ
             consumer_tag = 'foo'
             nowait = true
             method_frame = Cancel.encode(channel, consumer_tag, nowait)
-            method_frame.payload.should == "\x00<\x00\x1E\x03foo\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00\x1E\x03foo\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
         
@@ -144,7 +144,7 @@ module AMQ
             CancelOk.decode("\x03foo\x01")            
           end
 
-          its(:consumer_tag) { should == 'foo' }
+          its(:consumer_tag) { should eq('foo') }
         end
       end
 
@@ -154,7 +154,7 @@ module AMQ
             CancelOk.decode("\x03foo")
           end
           
-          its(:consumer_tag) { should == 'foo' }
+          its(:consumer_tag) { should eq('foo') }
         end
       end
 
@@ -170,13 +170,13 @@ module AMQ
             immediate = true
             frame_size = 512
             method_frames = Publish.encode(channel, payload, user_headers, exchange, routing_key, mandatory, immediate, frame_size)
-            method_frames[0].payload.should == "\x00<\x00(\x00\x00\x03foo\x03xyz\x02"
-            method_frames[1].payload.should == "\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\f\x88\x00\x18application/octet-stream\x00"
-            method_frames[2].payload.should == "Hello World!"
-            method_frames[0].channel.should == 1
-            method_frames[1].channel.should == 1
-            method_frames[2].channel.should == 1
-            method_frames.should have(3).items
+            expect(method_frames[0].payload).to eq("\x00<\x00(\x00\x00\x03foo\x03xyz\x02")
+            expect(method_frames[1].payload).to eq("\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\f\x88\x00\x18application/octet-stream\x00")
+            expect(method_frames[2].payload).to eq("Hello World!")
+            expect(method_frames[0].channel).to eq(1)
+            expect(method_frames[1].channel).to eq(1)
+            expect(method_frames[2].channel).to eq(1)
+            expect(method_frames.size).to eq(3)
           end
         end
       end
@@ -187,10 +187,10 @@ module AMQ
             Return.decode("\x019\fNO_CONSUMERS\namq.fanout\x00")
           end
           
-          its(:reply_code) { should == 313 }
-          its(:reply_text) { should == 'NO_CONSUMERS' }
-          its(:exchange) { should == 'amq.fanout' }
-          its(:routing_key) { should == '' }
+          its(:reply_code) { should eq(313) }
+          its(:reply_text) { should eq('NO_CONSUMERS') }
+          its(:exchange) { should eq('amq.fanout') }
+          its(:routing_key) { should eq('') }
         end
       end
 
@@ -200,11 +200,11 @@ module AMQ
             Deliver.decode("\e-1300560114000-445586772970\x00\x00\x00\x00\x00\x00\x00c\x00\namq.fanout\x00")
           end
           
-          its(:consumer_tag) { should == '-1300560114000-445586772970' }
-          its(:delivery_tag) { should == 99 }
-          its(:redelivered) { should == false }
-          its(:exchange) { should == 'amq.fanout' }
-          its(:routing_key) { should == '' }
+          its(:consumer_tag) { should eq('-1300560114000-445586772970') }
+          its(:delivery_tag) { should eq(99) }
+          its(:redelivered) { should eq(false) }
+          its(:exchange) { should eq('amq.fanout') }
+          its(:routing_key) { should eq('') }
         end
       end
       
@@ -215,8 +215,8 @@ module AMQ
             queue = 'foo'
             no_ack = true
             method_frame = Get.encode(channel, queue, no_ack)
-            method_frame.payload.should == "\x00\x3c\x00\x46\x00\x00\x03foo\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00\x3c\x00\x46\x00\x00\x03foo\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -227,11 +227,11 @@ module AMQ
             GetOk.decode("\x00\x00\x00\x00\x00\x00\x00\x06\x00\namq.fanout\x00\x00\x00\x00^")
           end
           
-          its(:delivery_tag) { should == 6 }
-          its(:redelivered) { should == false }
-          its(:exchange) { should == 'amq.fanout' }
-          its(:routing_key) { should == '' }
-          its(:message_count) { should == 94 }
+          its(:delivery_tag) { should eq(6) }
+          its(:redelivered) { should eq(false) }
+          its(:exchange) { should eq('amq.fanout') }
+          its(:routing_key) { should eq('') }
+          its(:message_count) { should eq(94) }
         end
       end
       
@@ -241,7 +241,7 @@ module AMQ
             GetEmpty.decode("\x03foo")
           end
           
-          its(:cluster_id) { should == 'foo' }
+          its(:cluster_id) { should eq('foo') }
         end
       end
 
@@ -252,8 +252,8 @@ module AMQ
             delivery_tag = 6
             multiple = false
             method_frame = Ack.encode(channel, delivery_tag, multiple)
-            method_frame.payload.should == "\x00<\x00P\x00\x00\x00\x00\x00\x00\x00\x06\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00P\x00\x00\x00\x00\x00\x00\x00\x06\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -265,8 +265,8 @@ module AMQ
             delivery_tag = 8
             requeue = true
             method_frame = Reject.encode(channel, delivery_tag, requeue)
-            method_frame.payload.should == "\x00<\x00Z\x00\x00\x00\x00\x00\x00\x00\x08\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00Z\x00\x00\x00\x00\x00\x00\x00\x08\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -277,8 +277,8 @@ module AMQ
             channel = 1
             requeue = true
             method_frame = RecoverAsync.encode(channel, requeue)
-            method_frame.payload.should == "\x00<\x00d\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00d\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -289,8 +289,8 @@ module AMQ
             channel = 1
             requeue = true
             method_frame = Recover.encode(channel, requeue)
-            method_frame.payload.should == "\x00<\x00n\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00n\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -306,9 +306,9 @@ module AMQ
             Nack.decode("\x00\x00\x00\x00\x00\x00\x00\x09\x03")
           end
           
-          its(:delivery_tag) { should == 9 }
-          its(:multiple) { should == true }
-          its(:requeue) { should == true }
+          its(:delivery_tag) { should eq(9) }
+          its(:multiple) { should eq(true) }
+          its(:requeue) { should eq(true) }
         end
         
         describe '.encode' do
@@ -318,11 +318,11 @@ module AMQ
             multiple = false
             requeue = true
             method_frame = Nack.encode(channel, delivery_tag, multiple, requeue)
-            method_frame.payload.should == "\x00<\x00x\x00\x00\x00\x00\x00\x00\x00\x0a\x02"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00<\x00x\x00\x00\x00\x00\x00\x00\x00\x0a\x02")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
     end
   end
-end
+end

data/spec/amq/protocol/blank_body_encoding_spec.rb

@@ -5,10 +5,10 @@ require File.expand_path('../../../spec_helper', __FILE__)
 
 describe AMQ::Protocol::Method, ".encode_body" do
   it "encodes 1-byte long payload as exactly 1 body frame" do
-    described_class.encode_body('1', 1, 65536).size.should == 1
+    expect(described_class.encode_body('1', 1, 65536).size).to eq(1)
   end
 
   it "encodes 0-byte long (blank) payload as exactly 0 body frame" do
-    described_class.encode_body('', 1, 65536).size.should == 0
+    expect(described_class.encode_body('', 1, 65536).size).to eq(0)
   end
 end

data/spec/amq/protocol/channel_spec.rb

@@ -12,8 +12,8 @@ module AMQ
             channel = 1
             out_of_band = ''
             method_frame = Open.encode(channel, out_of_band)
-            method_frame.payload.should == "\x00\x14\x00\n\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00\x14\x00\n\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -24,7 +24,7 @@ module AMQ
             OpenOk.decode("\x00\x00\x00\x03foo")
           end
 
-          its(:channel_id) { should == 'foo' }
+          its(:channel_id) { should eq('foo') }
         end
       end
 
@@ -34,7 +34,7 @@ module AMQ
             Flow.decode("\x01")
           end
 
-          its(:active) { should be_true }
+          its(:active) { should be_truthy }
         end
 
         describe '.encode' do
@@ -42,8 +42,8 @@ module AMQ
             channel = 1
             active = true
             method_frame = Flow.encode(channel, active)
-            method_frame.payload.should == "\x00\x14\x00\x14\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00\x14\x00\x14\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -54,7 +54,7 @@ module AMQ
             FlowOk.decode("\x00")
           end
 
-          its(:active) { should be_false }
+          its(:active) { should be_falsey }
         end
 
         describe '.encode' do
@@ -62,8 +62,8 @@ module AMQ
             channel = 1
             active = true
             method_frame = FlowOk.encode(channel, active)
-            method_frame.payload.should == "\x00\x14\x00\x15\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00\x14\x00\x15\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -75,10 +75,10 @@ module AMQ
               Close.decode("\x00\xc8\x07KTHXBAI\x00\x05\x00\x06")
             end
 
-            its(:reply_code) { should == 200 }
-            its(:reply_text) { should == 'KTHXBAI' }
-            its(:class_id) { should == 5 }
-            its(:method_id) { should == 6 }
+            its(:reply_code) { should eq(200) }
+            its(:reply_text) { should eq('KTHXBAI') }
+            its(:class_id) { should eq(5) }
+            its(:method_id) { should eq(6) }
           end
 
 
@@ -88,10 +88,10 @@ module AMQ
               Close.decode(raw)
             end
 
-            its(:reply_code) { should == 404 }
-            its(:reply_text) { should == %q{NOT_FOUND - no binding 123456789012345678901234567890123 between exchange 'amq.topic' in vhost '/' and queue 'test' in vhost '/'} }
-            its(:class_id) { should == 50 }
-            its(:method_id) { should == 50 }
+            its(:reply_code) { should eq(404) }
+            its(:reply_text) { should eq(%q{NOT_FOUND - no binding 123456789012345678901234567890123 between exchange 'amq.topic' in vhost '/' and queue 'test' in vhost '/'}) }
+            its(:class_id) { should eq(50) }
+            its(:method_id) { should eq(50) }
           end
 
           context 'with an error code' do
@@ -109,8 +109,8 @@ module AMQ
             class_id = 0
             method_id = 0
             method_frame = Close.encode(channel, reply_code, reply_text, class_id, method_id)
-            method_frame.payload.should == "\x00\x14\x00(\x02\x1c\x0fNOT_IMPLEMENTED\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00\x14\x00(\x02\x1c\x0fNOT_IMPLEMENTED\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -119,9 +119,9 @@ module AMQ
         describe '.encode' do
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
-            method_frame = CloseOk.encode(1)
-            method_frame.payload.should == "\x00\x14\x00\x29"
-            method_frame.channel.should == 1
+            method_frame = CloseOk.encode(channel)
+            expect(method_frame.payload).to eq("\x00\x14\x00\x29")
+            expect(method_frame.channel).to eq(channel)
           end
         end
       end