dispatch-rider 1.5.3 → 1.6.0

data/spec/lib/dispatch-rider/publisher/configuration_reader_spec.rb

@@ -11,7 +11,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
     subject { described_class }
 
     it "responds to :load_config" do
-      subject.should respond_to :load_config
+      expect(subject).to respond_to :load_config
     end
 
     it "requires 2 paramaters" do
@@ -28,7 +28,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
 
     describe "notification_services parsing" do
 
-      let(:configuration){ DispatchRider::Publisher::Configuration.new(configuration_hash) }
+      let(:configuration) { DispatchRider::Publisher::Configuration.new(configuration_hash) }
 
       context "when notification_services has no items in it" do
 
@@ -40,7 +40,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
         end
 
         it "doesn't call register_notification_service" do
-          publisher.should_not_receive(:register_notification_service)
+          expect(publisher).not_to receive(:register_notification_service)
           subject.load_config(configuration, publisher)
         end
       end
@@ -55,7 +55,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
         end
 
         it "calls register_notification_service with :file_system and {}" do
-          publisher.should_receive(:register_notification_service).with("file_system", {})
+          expect(publisher).to receive(:register_notification_service).with("file_system", {})
           subject.load_config(configuration, publisher)
         end
       end
@@ -71,8 +71,8 @@ describe DispatchRider::Publisher::ConfigurationReader do
         end
 
         it "calls register_notification_service with :file_system and {}, as well as :foo, {bar: '123'}" do
-          publisher.should_receive(:register_notification_service).with("file_system", {})
-          publisher.should_receive(:register_notification_service).with("foo", {"bar" => "123"})
+          expect(publisher).to receive(:register_notification_service).with("file_system", {})
+          expect(publisher).to receive(:register_notification_service).with("foo", "bar" => "123")
           subject.load_config(configuration, publisher)
         end
       end
@@ -81,7 +81,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
 
     describe "destinations" do
 
-      let(:configuration){ DispatchRider::Publisher::Configuration.new(configuration_hash) }
+      let(:configuration) { DispatchRider::Publisher::Configuration.new(configuration_hash) }
 
       context "when destinations has no items in it" do
 
@@ -93,7 +93,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
         end
 
         it "doesn't call register_destination" do
-          publisher.should_not_receive(:register_destination)
+          expect(publisher).not_to receive(:register_destination)
           subject.load_config(configuration, publisher)
         end
 
@@ -104,7 +104,7 @@ describe DispatchRider::Publisher::ConfigurationReader do
         let :configuration_hash do
           {
             destinations: {
-              out1:{
+              out1: {
                 service: :file_system,
                 channel: :foo,
                 options: {
@@ -116,7 +116,8 @@ describe DispatchRider::Publisher::ConfigurationReader do
         end
 
         it "should call register_destination with the right parameters" do
-          publisher.should_receive(:register_destination).exactly(1).times.with("out1", :file_system, :foo, "path" => "tmp/test/channel")
+          params = ["out1", :file_system, :foo, "path" => "tmp/test/channel"]
+          expect(publisher).to receive(:register_destination).exactly(1).times.with(*params)
           subject.load_config(configuration, publisher)
         end
 

data/spec/lib/dispatch-rider/publisher/configuration_spec.rb

@@ -31,13 +31,13 @@ describe DispatchRider::Publisher::Configuration do
     }
   end
 
-  subject{ described_class.new(configuration_hash) }
+  subject { described_class.new(configuration_hash) }
 
   describe "#notification services" do
     let(:file_system) do
       DispatchRider::Publisher::Configuration::NotificationService.new(
         "file_system",
-        { "default_folder" => "tmp/dispatch_rider" }
+        "default_folder" => "tmp/dispatch_rider"
       )
     end
 
@@ -46,8 +46,8 @@ describe DispatchRider::Publisher::Configuration do
     end
 
     it "contains both notification services" do
-      subject.notification_services.count.should == 2
-      subject.notification_services.should =~ [file_system, sns]
+      expect(subject.notification_services.count).to eq(2)
+      expect(subject.notification_services).to match_array([file_system, sns])
     end
   end
 
@@ -81,20 +81,20 @@ describe DispatchRider::Publisher::Configuration do
     end
 
     it "contains both destinations" do
-      subject.destinations.count.should == 2
-      subject.destinations.should =~ [employee_updates, account_updates]
+      expect(subject.destinations.count).to eq(2)
+      expect(subject.destinations).to match_array([employee_updates, account_updates])
     end
   end
 
   describe "#clear" do
     example do
-      expect{
+      expect {
         subject.clear
       }.to change(subject.notification_services, :count).by(-2)
     end
 
     example do
-      expect{
+      expect {
         subject.clear
       }.to change(subject.destinations, :count).by(-2)
     end
@@ -136,13 +136,13 @@ describe DispatchRider::Publisher::Configuration do
     end
 
     it "replaces the current notification services with the new notification service" do
-      subject.notification_services.count.should == 1
-      subject.notification_services.should =~ [notification_service]
+      expect(subject.notification_services.count).to eq(1)
+      expect(subject.notification_services).to match_array([notification_service])
     end
 
     it "replaces the current destinations with the new destination" do
-      subject.destinations.count.should == 1
-      subject.destinations.should =~ [destination]
+      expect(subject.destinations.count).to eq(1)
+      expect(subject.destinations).to match_array([destination])
     end
   end
 

data/spec/lib/dispatch-rider/publisher/configuration_support_spec.rb

@@ -2,17 +2,17 @@ require 'spec_helper'
 
 describe DispatchRider::Publisher::ConfigurationSupport do
 
-  subject{ Object.new.extend(described_class) }
+  subject { Object.new.extend(described_class) }
 
   describe ".configuration" do
     example do
-      subject.configuration.should be_a(DispatchRider::Publisher::Configuration)
+      expect(subject.configuration).to be_a(DispatchRider::Publisher::Configuration)
     end
   end
 
   describe ".config" do
     example do
-      subject.method(:config).should == subject.method(:configuration)
+      expect(subject.method(:config)).to eq(subject.method(:configuration))
     end
   end
 
@@ -57,13 +57,13 @@ describe DispatchRider::Publisher::ConfigurationSupport do
       end
 
       it "sets the configuration's notification services correctly" do
-        subject.configuration.notification_services.count.should == 1
-        subject.configuration.notification_services.should =~ [notification_service]
+        expect(subject.configuration.notification_services.count).to eq(1)
+        expect(subject.configuration.notification_services).to match_array([notification_service])
       end
 
       it "sets the configuration's destinations correctly" do
-        subject.configuration.destinations.count.should == 1
-        subject.configuration.destinations.should =~ [destination]
+        expect(subject.configuration.destinations.count).to eq(1)
+        expect(subject.configuration.destinations).to match_array([destination])
       end
     end
 
@@ -75,13 +75,13 @@ describe DispatchRider::Publisher::ConfigurationSupport do
       end
 
       it "sets the configuration's notification services correctly" do
-        subject.configuration.notification_services.count.should == 1
-        subject.configuration.notification_services.should =~ [notification_service]
+        expect(subject.configuration.notification_services.count).to eq(1)
+        expect(subject.configuration.notification_services).to match_array([notification_service])
       end
 
       it "sets the configuration's destinations correctly" do
-        subject.configuration.destinations.count.should == 1
-        subject.configuration.destinations.should =~ [destination]
+        expect(subject.configuration.destinations.count).to eq(1)
+        expect(subject.configuration.destinations).to match_array([destination])
       end
     end
   end

data/spec/lib/dispatch-rider/publisher_spec.rb

@@ -6,15 +6,15 @@ describe DispatchRider::Publisher do
 
   describe "#initialize" do
     it "assigns the notification service registrar" do
-      subject.notification_service_registrar.store.should be_empty
+      expect(subject.notification_service_registrar.store).to be_empty
     end
 
     it "assigns a publishing destination registrar" do
-      subject.publishing_destination_registrar.store.should be_empty
+      expect(subject.publishing_destination_registrar.store).to be_empty
     end
 
     it "assigns a service channel mapper" do
-      subject.service_channel_mapper.destination_registrar.store.should be_empty
+      expect(subject.service_channel_mapper.destination_registrar.store).to be_empty
     end
 
     # this case is broken because its playing chicken and the egg with the expectation
@@ -45,12 +45,12 @@ describe DispatchRider::Publisher do
     it "registers a notification service" do
       subject.register_notification_service(:aws_sns)
       result = subject.notification_service_registrar.fetch(:aws_sns)
-      result.notifier.should respond_to(:topics)
-      result.channel_registrar.store.should be_empty
+      expect(result.notifier).to respond_to(:topics)
+      expect(result.channel_registrar.store).to be_empty
     end
 
     it "returns the publisher" do
-      subject.register_notification_service(:aws_sns).should eq(subject)
+      expect(subject.register_notification_service(:aws_sns)).to eq(subject)
     end
   end
 
@@ -63,11 +63,11 @@ describe DispatchRider::Publisher do
 
     it "registers a channel for the notification service" do
       subject.register_channel(:aws_sns, :foo, account: 123, region: "us-east-1", topic: "PlanOfAttack")
-      notification_service.channel_registrar.fetch(:foo).should eq('arn:aws:sns:us-east-1:123:PlanOfAttack')
+      expect(notification_service.channel_registrar.fetch(:foo)).to eq('arn:aws:sns:us-east-1:123:PlanOfAttack')
     end
 
     it "returns the publisher" do
-      subject.register_channel(:aws_sns, :foo).should eq(subject)
+      expect(subject.register_channel(:aws_sns, :foo)).to eq(subject)
     end
   end
 
@@ -79,12 +79,19 @@ describe DispatchRider::Publisher do
     it "registers the destination to be published to" do
       subject.register_destination(:sns_foo, :aws_sns, :foo, account: 123, region: "us-east-1", topic: "PlanOfAttack")
       result = subject.publishing_destination_registrar.fetch(:sns_foo)
-      result.service.should eq(:aws_sns)
-      result.channel.should eq(:foo)
+      expect(result.service).to eq(:aws_sns)
+      expect(result.channel).to eq(:foo)
     end
 
     it "returns the publisher" do
-      subject.register_destination(:sns_foo, :aws_sns, :foo, account: 123, region: "us-east-1", topic: "PlanOfAttack").should eq(subject)
+      result = subject.register_destination(:sns_foo,
+                                            :aws_sns,
+                                            :foo,
+                                            account: 123,
+                                            region: "us-east-1",
+                                            topic: "PlanOfAttack"
+      )
+      expect(result).to eq(subject)
     end
   end
 
@@ -110,7 +117,7 @@ describe DispatchRider::Publisher do
     it "publishes the message to the notification service" do
       existing = Dir['tmp/test_queue/*']
       expect {
-        subject.publish(:destinations => [:fs_foo], :message => {:subject => "bar_handler", :body => {"bar" => "baz"}})
+        subject.publish(:destinations => [:fs_foo], message: { subject: "bar_handler", body: { "bar" => "baz" } })
       }.to change { Dir['tmp/test_queue/*'].length }.by(1)
       new_job = Dir['tmp/test_queue/*'] - existing
       data = JSON.load(File.read(new_job.first))
@@ -142,9 +149,9 @@ describe DispatchRider::Publisher do
         after { DispatchRider.config.callbacks.for(:publish).delete publish_callback }
 
         example do
-          publish_callback.should_receive(:call).with any_args, # first argument is the inner job
-                                                      destinations: [:fs_foo],
-                                                      message: expected_message
+          expect(publish_callback).to receive(:call).with any_args, # first argument is the inner job
+                                                          destinations: [:fs_foo],
+                                                          message: expected_message
 
           publisher.publish destinations: [:fs_foo],
                             message: {

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

@@ -47,7 +47,7 @@ describe DispatchRider::QueueServices::AwsSqs do
 
   describe "#insert" do
     it "should insert an item into the queue" do
-      obj = {'subject' => 'foo', 'body' => 'bar'}.to_json
+      obj = { 'subject' => 'foo', 'body' => 'bar' }.to_json
       expect(aws_sqs_queue.queue).to receive(:send_message).with(obj)
       aws_sqs_queue.insert(obj)
     end
@@ -66,26 +66,26 @@ describe DispatchRider::QueueServices::AwsSqs do
 
       let(:response_message) do
         {
-          :message_id => 12345,
-          :md5_of_body => "mmmddd555",
-          :body => {:subject => "foo", :body => {:bar => "baz"}}.to_json,
-          :receipt_handle => "HANDLE",
-          :attributes => response_attributes,
+          message_id: 12345,
+          md5_of_body: "mmmddd555",
+          body: { subject: "foo", body: { bar: "baz" } }.to_json,
+          receipt_handle: "HANDLE",
+          attributes: response_attributes,
         }
       end
 
       before :each do
         response = AWS::SQS::Client.new.stub_for(:receive_message)
         response.data[:messages] = [response_message]
-        AWS::SQS::Client::V20121105.any_instance.stub(:receive_message).and_return(response)
-        AWS::SQS::Queue.any_instance.stub(:verify_receive_message_checksum).and_return([])
+        allow_any_instance_of(AWS::SQS::Client::V20121105).to receive(:receive_message).and_return(response)
+        allow_any_instance_of(AWS::SQS::Queue).to receive(:verify_receive_message_checksum).and_return([])
       end
 
       context "when the block runs faster than the timeout" do
         it "should yield the first item in the queue" do
           aws_sqs_queue.pop do |message|
             expect(message.subject).to eq('foo')
-            expect(message.body).to eq({'bar' => 'baz'})
+            expect(message.body).to eq('bar' => 'baz')
           end
         end
       end
@@ -106,7 +106,7 @@ describe DispatchRider::QueueServices::AwsSqs do
 
     context "when the sqs queue is empty" do
       before :each do
-        aws_sqs_queue.queue.stub(:receive_message).and_return(nil)
+        allow(aws_sqs_queue.queue).to receive(:receive_message).and_return(nil)
       end
 
       it "should not yield" do
@@ -119,74 +119,82 @@ describe DispatchRider::QueueServices::AwsSqs do
   end
 
   describe "received message methods" do
-    let(:response_attributes) {{
+    let(:response_attributes) do
+      {
         "SenderId" => "123456789012",
         "SentTimestamp" => Time.now.to_i.to_s,
         "ApproximateReceivedCount" => "12",
         "ApproximateFirstReceiveTimestamp" => (Time.now + 12).to_i.to_s,
-      }}
+      }
+    end
 
-      let(:response_message) { {
-        :message_id => 12345,
-        :md5_of_body => "mmmddd555",
-        :body => {:subject => "foo", :body => {:bar => "baz"}}.to_json,
-        :receipt_handle => "HANDLE",
-        :attributes => response_attributes,
-      } }
+    let(:response_message) do
+      {
+        message_id: 12345,
+        md5_of_body: "mmmddd555",
+        body: { subject: "foo", body: { bar: "baz" } }.to_json,
+        receipt_handle: "HANDLE",
+        attributes: response_attributes,
+      }
+    end
 
-      before :each do
-        response = AWS::SQS::Client.new.stub_for(:receive_message)
-        response.data[:messages] = [response_message]
-        AWS::SQS::Client::V20121105.any_instance.stub(:receive_message).and_return(response)
-        AWS::SQS::Queue.any_instance.stub(:verify_receive_message_checksum).and_return([])
-      end
+    before :each do
+      response = AWS::SQS::Client.new.stub_for(:receive_message)
+      response.data[:messages] = [response_message]
+      allow_any_instance_of(AWS::SQS::Client::V20121105).to receive(:receive_message).and_return(response)
+      allow_any_instance_of(AWS::SQS::Queue).to receive(:verify_receive_message_checksum).and_return([])
+    end
 
     it "should set the visibility timeout when extend is called" do
       expect_any_instance_of(AWS::SQS::ReceivedMessage).to receive(:visibility_timeout=).with(10)
       expect_any_instance_of(AWS::SQS::ReceivedMessage).to receive(:visibility_timeout=).with(0)
       aws_sqs_queue.pop do |message|
         message.extend_timeout(10)
-        message.total_timeout.should eq(10)
+        expect(message.total_timeout).to eq(10)
         message.return_to_queue
-        message.total_timeout.should eq(10)
+        expect(message.total_timeout).to eq(10)
       end
     end
   end
 
   describe "#construct_message_from" do
     context "when the item is directly published to AWS::SQS" do
-      let(:sqs_message){ OpenStruct.new(:body => {'subject' => 'foo', 'body' => 'bar'}.to_json) }
+      let(:sqs_message) { OpenStruct.new(body: { 'subject' => 'foo', 'body' => 'bar' }.to_json) }
 
       it "should return a message" do
         result = aws_sqs_queue.construct_message_from(sqs_message)
-        result.subject.should eq('foo')
-        result.body.should eq('bar')
+        expect(result.subject).to eq('foo')
+        expect(result.body).to eq('bar')
       end
     end
 
     context "when the item is published through AWS::SNS" do
-      let(:sqs_message){ OpenStruct.new(:body => {"Type" => "Notification", "Message" => {'subject' => 'foo', 'body' => 'bar'}.to_json}.to_json) }
+      let(:sqs_message) do
+        message = { 'subject' => 'foo', 'body' => 'bar' }
+        body = { "Type" => "Notification", "Message" => message.to_json }.to_json
+        OpenStruct.new(body: body)
+      end
 
       it "should return a message" do
         result = aws_sqs_queue.construct_message_from(sqs_message)
-        result.subject.should eq('foo')
-        result.body.should eq('bar')
+        expect(result.subject).to eq('foo')
+        expect(result.body).to eq('bar')
       end
     end
   end
 
   describe "#delete" do
-    let(:item_in_queue){ Object.new }
+    let(:item_in_queue) { Object.new }
 
     it "should delete the first message from the queue" do
-      item_in_queue.should_receive(:delete)
+      expect(item_in_queue).to receive(:delete)
       aws_sqs_queue.delete(item_in_queue)
     end
   end
 
   describe "#size" do
     it "should return the size of the aws queue" do
-      aws_sqs_queue.queue.should_receive(:approximate_number_of_messages)
+      expect(aws_sqs_queue.queue).to receive(:approximate_number_of_messages)
       aws_sqs_queue.size
     end
   end