dispatch-rider 1.5.3 → 1.6.0

data/spec/lib/dispatch-rider/queue_services/base_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe DispatchRider::QueueServices::Base do
   subject(:base_queue) do
-    DispatchRider::QueueServices::Base.any_instance.stub(:assign_storage).and_return([])
+    allow_any_instance_of(DispatchRider::QueueServices::Base).to receive(:assign_storage).and_return([])
     DispatchRider::QueueServices::Base.new
   end
 
   describe "#initialize" do
     it "should initiate a queue" do
-      base_queue.queue.should eq([])
+      expect(base_queue.queue).to eq([])
     end
   end
 
@@ -16,16 +16,18 @@ describe DispatchRider::QueueServices::Base do
     subject(:simple_queue) { DispatchRider::QueueServices::Simple.new }
 
     it "should push the serialized object to the queue" do
-      simple_queue.push(DispatchRider::Message.new(:subject => "foo", :body => "bar"))
+      simple_queue.push(DispatchRider::Message.new(subject: "foo", body: "bar"))
       result = JSON.parse(simple_queue.queue.first)
-      result['subject'].should eq('foo')
-      result['body'].should eq('bar')
+      expect(result['subject']).to eq('foo')
+      expect(result['body']).to eq('bar')
     end
   end
 
   describe "#insert" do
     it "should raise an exception" do
-      expect { base_queue.insert(DispatchRider::Message.new(:subject => "foo", :body => "bar")) }.to raise_exception(NotImplementedError)
+      expect {
+        base_queue.insert(DispatchRider::Message.new(subject: "foo", body: "bar"))
+      }.to raise_exception(NotImplementedError)
     end
   end
 
@@ -33,26 +35,28 @@ describe DispatchRider::QueueServices::Base do
     subject(:simple_queue) { DispatchRider::QueueServices::Simple.new }
 
     before :each do
-      simple_queue.queue.push(DispatchRider::Message.new(:subject => "foo", :body => "bar").to_json)
+      simple_queue.queue.push(DispatchRider::Message.new(subject: "foo", body: "bar").to_json)
     end
 
     context "when the block passed to process the popped message returns true" do
       it "should return the first message in the queue" do
-        simple_queue.pop {|msg| true}.should eq(DispatchRider::Message.new(:subject => 'foo', :body => 'bar'))
+        response = simple_queue.pop { |_msg| true }
+        expect(response).to eq(DispatchRider::Message.new(subject: 'foo', body: 'bar'))
       end
     end
 
     context "when the block passed to process the popped message returns false" do
       it "should return the first message in the queue" do
-        simple_queue.pop {|msg| false}.should eq(DispatchRider::Message.new(:subject => 'foo', :body => 'bar'))
+        result = simple_queue.pop { |_msg| false }
+        expect(result).to eq(DispatchRider::Message.new(subject: 'foo', body: 'bar'))
       end
 
       it "should not remove the first message from the queue" do
         simple_queue.pop do |msg|
-          msg.body = {:bar => "baz"}
+          msg.body = { bar: "baz" }
           false
         end
-        simple_queue.should_not be_empty
+        expect(simple_queue).not_to be_empty
       end
     end
 
@@ -62,35 +66,40 @@ describe DispatchRider::QueueServices::Base do
       end
 
       it "should return nil" do
-        simple_queue.pop do |msg|
-          msg.body = {:bar => "baz"}
+        result = simple_queue.pop do |msg|
+          msg.body = { bar: "baz" }
           true
-        end.should be_nil
+        end
+        expect(result).to be_nil
       end
     end
   end
 
   describe "#head" do
-    before { base_queue.stub(:raw_head).and_return(new_item) }
+    before do
+      allow(base_queue).to receive(:raw_head) { new_item }
+    end
 
     context "when there is no new item" do
-      let(:new_item){ nil }
+      let(:new_item) { nil }
 
       it "should raise an exception" do
-        base_queue.head.should be_nil
+        expect(base_queue.head).to be_nil
       end
     end
 
     context "when a new item exists" do
-      before { base_queue.stub(:construct_message_from){|item| item.message} }
+      before do
+        allow(base_queue).to receive(:construct_message_from) { |item| item.message }
+      end
 
-      let(:new_item){ OpenStruct.new(:message => new_message) }
-      let(:new_message){ :the_message }
+      let(:new_item) { OpenStruct.new(message: new_message) }
+      let(:new_message) { :the_message }
 
       it "should return the expected message" do
         received_head = base_queue.head
-        received_head.item.should == new_item
-        received_head.to_sym == new_message
+        expect(received_head.item).to eq new_item
+        expect(received_head.to_sym).to eq new_message
       end
     end
   end
@@ -103,19 +112,23 @@ describe DispatchRider::QueueServices::Base do
 
   describe "#construct_message_from" do
     it "should raise an exception" do
-      expect { base_queue.construct_message_from({:subject => 'foo', :body => {:bar => 'baz'}}.to_json) }.to raise_exception(NotImplementedError)
+      expect {
+        base_queue.construct_message_from({ subject: 'foo', body: { bar: 'baz' } }.to_json)
+      }.to raise_exception(NotImplementedError)
     end
   end
 
   describe "#delete" do
     it "should raise an exception" do
-      expect { base_queue.delete({:subject => 'foo', :body => {:bar => 'baz'}}.to_json) }.to raise_exception(NotImplementedError)
+      expect {
+        base_queue.delete({ subject: 'foo', body: { bar: 'baz' } }.to_json)
+      }.to raise_exception(NotImplementedError)
     end
   end
 
   describe "#empty?" do
     before :each do
-      base_queue.stub(:size) { base_queue.queue.size }
+      allow(base_queue).to receive(:size) { base_queue.queue.size }
     end
 
     context "when the queue is empty" do
@@ -124,17 +137,17 @@ describe DispatchRider::QueueServices::Base do
       end
 
       it "should return true" do
-        base_queue.should be_empty
+        expect(base_queue).to be_empty
       end
     end
 
     context "when the queue is not empty" do
       before :each do
-        base_queue.queue << {:subject => 'foo', :body => 'bar'}.to_json
+        base_queue.queue << { subject: 'foo', body: 'bar' }.to_json
       end
 
       it "should return false" do
-        base_queue.should_not be_empty
+        expect(base_queue).not_to be_empty
       end
     end
   end

data/spec/lib/dispatch-rider/queue_services/file_system_spec.rb

@@ -7,11 +7,12 @@ describe DispatchRider::QueueServices::FileSystem do
     DispatchRider::QueueServices::FileSystem.new(:path => queue_path)
   end
 
-  before { file_system_queue.send(:queue).send(:file_paths).each{|file| File.unlink(file)} }
+  before { file_system_queue.send(:queue).send(:file_paths).each { |file| File.unlink(file) } }
 
   describe "#assign_storage" do
     it "should return an empty array" do
-      file_system_queue.assign_storage({:path => queue_path}).should be_a DispatchRider::QueueServices::FileSystem::Queue
+      expected_type = DispatchRider::QueueServices::FileSystem::Queue
+      expect(file_system_queue.assign_storage(path: queue_path)).to be_a expected_type
     end
   end
 
@@ -19,8 +20,8 @@ describe DispatchRider::QueueServices::FileSystem do
     it "should insert a serialized object into the queue" do
       file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
       result = JSON.parse(file_system_queue.queue.pop.read)
-      result['subject'].should eq('foo')
-      result['body'].should eq('bar')
+      expect(result['subject']).to eq('foo')
+      expect(result['body']).to eq('bar')
     end
   end
 
@@ -31,8 +32,8 @@ describe DispatchRider::QueueServices::FileSystem do
 
     it "should return the first item from the queue" do
       result = JSON.parse(file_system_queue.raw_head.read)
-      result['subject'].should eq('foo')
-      result['body'].should eq('bar')
+      expect(result['subject']).to eq('foo')
+      expect(result['body']).to eq('bar')
     end
   end
 
@@ -46,21 +47,21 @@ describe DispatchRider::QueueServices::FileSystem do
 
     it "should return the item casted as a message" do
       result = file_system_queue.construct_message_from(new_file)
-      result.subject.should eq('foo')
-      result.body.should eq('bar')
+      expect(result.subject).to eq('foo')
+      expect(result.body).to eq('bar')
     end
   end
-  
+
   describe "#put_back" do
     before :each do
       file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
     end
-    
+
     it "should remove and re-add the item" do
       file = file_system_queue.raw_head
-      file_system_queue.should be_empty
+      expect(file_system_queue).to be_empty
       file_system_queue.put_back(file)
-      file_system_queue.size.should eq(1)
+      expect(file_system_queue.size).to eq(1)
     end
   end
 
@@ -72,7 +73,7 @@ describe DispatchRider::QueueServices::FileSystem do
     it "should remove the item from the queue" do
       file = File.new(Dir["#{queue_path}/*.ready"].first, "w")
       file_system_queue.delete(file)
-      file_system_queue.should be_empty
+      expect(file_system_queue).to be_empty
     end
   end
 
@@ -82,7 +83,7 @@ describe DispatchRider::QueueServices::FileSystem do
     end
 
     it "should return the size of the queue" do
-      file_system_queue.size.should eq(1)
+      expect(file_system_queue.size).to eq(1)
     end
   end
 end

data/spec/lib/dispatch-rider/queue_services/received_message_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe DispatchRider::QueueServices::ReceivedMessage do
 
-  subject{ described_class.new("test_message", double(:item)) }
+  subject { described_class.new("test_message", double(:item)) }
 
   describe "#extend_timeout" do
     example do
-      expect{
+      expect {
         subject.extend_timeout(10)
       }.to raise_error NotImplementedError
     end
@@ -14,7 +14,7 @@ describe DispatchRider::QueueServices::ReceivedMessage do
 
   describe "#return_to_queue" do
     example do
-      expect{
+      expect {
         subject.return_to_queue
       }.to raise_error NotImplementedError
     end

data/spec/lib/dispatch-rider/queue_services/simple_spec.rb

@@ -7,7 +7,7 @@ describe DispatchRider::QueueServices::Simple do
 
   describe "#assign_storage" do
     it "should return an empty array" do
-      simple_queue.assign_storage({}).should eq([])
+      expect(simple_queue.assign_storage({})).to eq([])
     end
   end
 
@@ -15,8 +15,8 @@ describe DispatchRider::QueueServices::Simple do
     it "should insert a serialized object into the queue" do
       simple_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
       result = JSON.parse(simple_queue.queue.pop)
-      result['subject'].should eq('foo')
-      result['body'].should eq('bar')
+      expect(result['subject']).to eq('foo')
+      expect(result['body']).to eq('bar')
     end
   end
 
@@ -27,16 +27,16 @@ describe DispatchRider::QueueServices::Simple do
 
     it "should return the first item from the queue" do
       result = JSON.parse(simple_queue.raw_head)
-      result['subject'].should eq('foo')
-      result['body'].should eq('bar')
+      expect(result['subject']).to eq('foo')
+      expect(result['body']).to eq('bar')
     end
   end
 
   describe "#construct_message_from" do
     it "should return the item casted as a message" do
       result = simple_queue.construct_message_from({'subject' => 'foo', 'body' => 'bar'}.to_json)
-      result.subject.should eq('foo')
-      result.body.should eq('bar')
+      expect(result.subject).to eq('foo')
+      expect(result.body).to eq('bar')
     end
   end
 
@@ -47,7 +47,7 @@ describe DispatchRider::QueueServices::Simple do
 
     it "should remove the item from the queue" do
       simple_queue.delete({'subject' => 'foo', 'body' => 'bar'}.to_json)
-      simple_queue.should be_empty
+      expect(simple_queue).to be_empty
     end
   end
 
@@ -57,7 +57,7 @@ describe DispatchRider::QueueServices::Simple do
     end
 
     it "should return the size of the queue" do
-      simple_queue.size.should eq(1)
+      expect(simple_queue.size).to eq(1)
     end
   end
 end

data/spec/lib/dispatch-rider/registrars/base_spec.rb

@@ -25,7 +25,7 @@ describe DispatchRider::Registrars::Base do
 
     context "when there is a missing constant while registering" do
       it "raises an exception" do
-        subject.should_receive(:value).with(:foo, {}) { 'bar'.camelize.constantize }
+        expect(subject).to receive(:value).with(:foo, {}) { 'bar'.camelize.constantize }
         expect { subject.register(:foo) }.to raise_exception(DispatchRider::NotFound)
       end
     end
@@ -33,7 +33,7 @@ describe DispatchRider::Registrars::Base do
 
   describe "#unregister" do
     before :each do
-      subject.stub(:value).and_return('bar')
+      allow(subject).to receive(:value).and_return('bar')
       subject.register(:foo)
     end
 
@@ -43,19 +43,19 @@ describe DispatchRider::Registrars::Base do
     end
 
     it "returns the registrar" do
-      subject.unregister(:foo).should eq(subject)
+      expect(subject.unregister(:foo)).to eq(subject)
     end
   end
 
   describe "#fetch" do
     context "when a key/value pair is registered" do
       before :each do
-        subject.stub(:value).and_return('bar')
+        allow(subject).to receive(:value).and_return('bar')
         subject.register(:foo)
       end
 
       it "return the value for the key" do
-        subject.fetch(:foo).should eq('bar')
+        expect(subject.fetch(:foo)).to eq('bar')
       end
     end
 

data/spec/lib/dispatch-rider/registrars/file_system_channel_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe DispatchRider::Registrars::FileSystemChannel do
   describe "#value" do
-    let(:path){ "/foo/bar" }
-    let(:channel_options){ {path: path} }
+    let(:path) { "/foo/bar" }
+    let(:channel_options) { { path: path } }
 
     it "returns the expanded path from the options" do
-      subject.value(:foo, channel_options).should eq("/foo/bar")
+      expect(subject.value(:foo, channel_options)).to eq("/foo/bar")
     end
   end
 end

data/spec/lib/dispatch-rider/registrars/handler_spec.rb

@@ -10,7 +10,7 @@ describe DispatchRider::Registrars::Handler do
 
   describe "#value" do
     it "returns the value for the key/value pair while registering a handler" do
-      subject.value(:custom_test_handler).should eq(CustomTestHandler)
+      expect(subject.value(:custom_test_handler)).to eq(CustomTestHandler)
     end
   end
 end

data/spec/lib/dispatch-rider/registrars/notification_service_spec.rb

@@ -7,7 +7,7 @@ describe DispatchRider::Registrars::NotificationService do
 
   describe "#value" do
     it "returns the value for the key/value pair while registering a notification service" do
-      subject.value(:aws_sns).should be_a(DispatchRider::NotificationServices::AwsSns)
+      expect(subject.value(:aws_sns)).to be_a(DispatchRider::NotificationServices::AwsSns)
     end
   end
 end

data/spec/lib/dispatch-rider/registrars/publishing_destination_spec.rb

@@ -4,8 +4,8 @@ describe DispatchRider::Registrars::PublishingDestination do
   describe "#value" do
     it "returns an object which has information about a notification service and a channel" do
       result = subject.value('foo', :service => :aws_sns, :channel => :bar)
-      result.service.should eq(:aws_sns)
-      result.channel.should eq(:bar)
+      expect(result.service).to eq(:aws_sns)
+      expect(result.channel).to eq(:bar)
     end
   end
 end

data/spec/lib/dispatch-rider/registrars/queue_service_spec.rb

@@ -7,7 +7,7 @@ describe DispatchRider::Registrars::QueueService do
 
   describe "#value" do
     it "returns the value for the key/value pair while registering a queue service" do
-      subject.value(:simple).should be_a(DispatchRider::QueueServices::Simple)
+      expect(subject.value(:simple)).to be_a(DispatchRider::QueueServices::Simple)
     end
   end
 end

data/spec/lib/dispatch-rider/registrars/sns_channel_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe DispatchRider::Registrars::SnsChannel do
   describe "#value" do
-    let(:account){ "123456789012" }
-    let(:region){ "us-west-2" }
-    let(:topic_name){ "GeneralTopic" }
-    let(:channel_options){ {account: account, region: region, topic: topic_name} }
+    let(:account) { "123456789012" }
+    let(:region) { "us-west-2" }
+    let(:topic_name) { "GeneralTopic" }
+    let(:channel_options) { { account: account, region: region, topic: topic_name } }
 
     it "returns the value for the key/value pair while registering an amazon sns channel" do
-      subject.value(:foo, channel_options).should eq("arn:aws:sns:us-west-2:123456789012:GeneralTopic")
+      expect(subject.value(:foo, channel_options)).to eq("arn:aws:sns:us-west-2:123456789012:GeneralTopic")
     end
   end
 end