dispatch-rider 1.5.3 → 1.6.0

data/spec/lib/dispatch-rider/logging/text_formatter_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe DispatchRider::Logging::TextFormatter do
+  let(:fs_message) { DispatchRider::Message.new(subject: 'test', body: { 'key' => 'value', 'guid' => 123 }) }
+  let(:item) { double :item }
+  let(:queue) { double :queue }
+  let(:message) { DispatchRider::QueueServices::FileSystem::FsReceivedMessage.new(fs_message, item, queue) }
+
+  let(:string_to_log) { "string to log" }
+  let(:exception) { StandardError.new }
+  let(:reason) { "Stop reason" }
+
+  before do
+    allow(subject).to receive(:message_info_fragment).and_return(string_to_log)
+    allow(subject).to receive(:exception_info_fragment).and_return(string_to_log)
+  end
+
+  context "format_error_handler_fail" do
+    let(:formatted_message) { "Failed error handling of: string to log" }
+    example do
+      expect(subject.format_error_handler_fail(message, exception)).to eq(formatted_message)
+    end
+  end
+
+  context "format_got_stop" do
+    let(:formatted_message) { "Got stop (Stop reason) while executing: string to log" }
+    example do
+      expect(subject.format_got_stop(message, reason)).to eq(formatted_message)
+    end
+  end
+
+  context "format_handling" do
+    context "start" do
+      let(:formatted_message) { "Starting execution of: string to log" }
+      example do
+        expect(subject.format_handling(:start, message)).to eq(formatted_message)
+      end
+    end
+
+    context "success" do
+      let(:formatted_message) { "Succeeded execution of: string to log" }
+      example do
+        expect(subject.format_handling(:success, message)).to eq(formatted_message)
+      end
+    end
+
+    context "complete" do
+      let(:formatted_message) { "Completed execution of: string to log in 2.12 seconds" }
+      example do
+        expect(subject.format_handling(:complete, message, duration: 2.12)).to eq(formatted_message)
+      end
+    end
+
+    context "fail" do
+      let(:formatted_message) { "Failed execution of: string to log" }
+      example do
+        expect(subject.format_handling(:fail, message, exception: exception)).to eq(formatted_message)
+      end
+    end
+  end
+end

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

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
 describe DispatchRider::Message do
-  subject(:message) {DispatchRider::Message.new(:subject => 'test', :body => 'test_handler')}
+  subject(:message) { DispatchRider::Message.new(subject: 'test', body: 'test_handler') }
 
   describe "#initialize" do
     context "when all the required attributes are passed" do
       context "when the attributes hash has keys as strings" do
-        subject(:message) {DispatchRider::Message.new('subject' => 'test', 'body' => 'test_handler')}
+        subject(:message) { DispatchRider::Message.new('subject' => 'test', 'body' => 'test_handler') }
 
         it "should initiate a new message" do
-          message.subject.should eq('test')
-          message.body.should eq('test_handler')
+          expect(message.subject).to eq('test')
+          expect(message.body).to eq('test_handler')
         end
       end
 
       context "when the attributes hash has keys as symbols" do
         it "should initiate a new message" do
-          message.subject.should eq('test')
-          message.body.should eq('test_handler')
+          expect(message.subject).to eq('test')
+          expect(message.body).to eq('test_handler')
         end
       end
     end
@@ -31,28 +31,28 @@ describe DispatchRider::Message do
 
   describe "#attributes" do
     it "should return the attributes hash of the message" do
-      message.attributes.should eq({:subject => 'test', :body => 'test_handler'})
+      expect(message.attributes).to eq(subject: 'test', body: 'test_handler')
     end
   end
 
   describe "#to_json" do
     it "should return the attributes hash in json format" do
       result = JSON.parse(message.to_json)
-      result['subject'].should eq('test')
-      result['body'].should eq('test_handler')
+      expect(result['subject']).to eq('test')
+      expect(result['body']).to eq('test_handler')
     end
   end
 
   describe "#==" do
     context "when 2 messages have the same attribute values" do
       it "should return true" do
-        message.should eq(DispatchRider::Message.new(:subject => 'test', :body => 'test_handler'))
+        expect(message).to eq(DispatchRider::Message.new(subject: 'test', body: 'test_handler'))
       end
     end
 
     context "when 2 messages do not have same attribute values" do
       it "should return false" do
-        message.should_not eq(DispatchRider::Message.new(:subject => 'random_test', :body => 'test_handler'))
+        expect(message).not_to eq(DispatchRider::Message.new(subject: 'random_test', body: 'test_handler'))
       end
     end
   end

data/spec/lib/dispatch-rider/notification_services/aws_sns_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
 describe DispatchRider::NotificationServices::AwsSns do
-  let(:amazon_resource_name){ "arn:aws:sns:us-west-2:123456789012:GeneralTopic" }
+  let(:amazon_resource_name) { "arn:aws:sns:us-west-2:123456789012:GeneralTopic" }
 
   describe "#notifier_builder" do
     it "returns the notifier builder" do
-      subject.notifier_builder.should eq(AWS::SNS)
+      expect(subject.notifier_builder).to eq(AWS::SNS)
     end
   end
 
   describe "#channel_registrar_builder" do
     it "returns the channel registrar builder" do
-      subject.channel_registrar_builder.should eq(DispatchRider::Registrars::SnsChannel)
+      expect(subject.channel_registrar_builder).to eq(DispatchRider::Registrars::SnsChannel)
     end
   end
 
@@ -21,25 +21,26 @@ describe DispatchRider::NotificationServices::AwsSns do
 
     # @note: This is tested this way cause you don't really wanna post a message to the actual service.
     it "publishes the message to the channels" do
-      expect(channel).to receive(:publish).with(kind_of String) { |serialized_message|
-        expect(JSON.parse(serialized_message)).to eq(
-          "subject" => "test_handler",
-          "body" => { "bar" => "baz" }
-        )
-      }
+      expect(channel).to receive(:publish).with(kind_of String) do |serialized_message|
+                           expected = {
+                             "subject" => "test_handler",
+                             "body" => { "bar" => "baz" }
+                           }
+                           expect(JSON.parse(serialized_message)).to eq(expected)
+                         end
 
       subject.publish_to_channel(channel, message: message)
     end
   end
 
   describe "#channel" do
-    before { subject.stub(:channel_registrar).and_return(foo: amazon_resource_name) }
+    before { allow(subject).to receive(:channel_registrar).and_return(foo: amazon_resource_name) }
 
-    let(:topics){ double :sns_topics }
-    let(:topic){ double :sns_topic }
+    let(:topics) { double :sns_topics }
+    let(:topic) { double :sns_topic }
 
     it "returns the channel" do
-      subject.channel(:foo).arn.should == amazon_resource_name
+      expect(subject.channel(:foo).arn).to eq(amazon_resource_name)
     end
   end
 end

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

@@ -12,24 +12,25 @@ describe DispatchRider::NotificationServices::Base do
   end
 
   before :each do
-    DispatchRider::NotificationServices::Base.any_instance.stub(:notifier_builder).and_return(OpenStruct)
-    DispatchRider::NotificationServices::Base.any_instance.stub(:channel_registrar_builder).and_return(DispatchRider::Registrars::SnsChannel)
-    DispatchRider::NotificationServices::Base.any_instance.stub(:channel) do |name|
+    allow_any_instance_of(described_class).to receive(:notifier_builder).and_return(OpenStruct)
+    channel = DispatchRider::Registrars::SnsChannel
+    allow_any_instance_of(described_class).to receive(:channel_registrar_builder).and_return(channel)
+    allow_any_instance_of(described_class).to receive(:channel) do |name|
       subject.notifier.topics[subject.fetch(name)] if name == :foo
     end
   end
 
   subject do
-    DispatchRider::NotificationServices::Base.new({:topics => {}})
+    DispatchRider::NotificationServices::Base.new(topics: {})
   end
 
   describe "#initialize" do
     it "assigns the notifier" do
-      subject.notifier.should respond_to(:topics)
+      expect(subject.notifier).to respond_to(:topics)
     end
 
     it "assigns the channel registrar" do
-      subject.channel_registrar.store.should be_empty
+      expect(subject.channel_registrar.store).to be_empty
     end
   end
 
@@ -42,7 +43,7 @@ describe DispatchRider::NotificationServices::Base do
     let(:message) { DispatchRider::Message.new(subject: :test_handler, body: { "bar" => "baz" }) }
 
     it "publishes the message to the channels" do
-      catch(:published) { subject.publish to: :foo, message: message }.should eq("baz")
+      expect(catch(:published) { subject.publish to: :foo, message: message }).to eq("baz")
     end
   end
 
@@ -50,15 +51,19 @@ describe DispatchRider::NotificationServices::Base do
     let(:channel) { double(:channel) }
 
     let(:message) { DispatchRider::Message.new(subject: :test_handler, body: { "bar" => "baz" }) }
+    let(:expected_message) do
+      {
+        "subject" => "test_handler",
+        "body" => { "bar" => "baz" }
+      }
+    end
 
     # @note: This is tested this way cause you don't really wanna post a message to the actual service.
     it "publishes the message to the channels" do
       expect(channel).to receive(:publish).with(kind_of String) { |serialized_message|
-        expect(JSON.parse(serialized_message)).to eq(
-          "subject" => "test_handler",
-          "body" => { "bar" => "baz" }
-        )
-      }
+                           parsed_message = JSON.parse(serialized_message)
+                           expect(parsed_message).to eq(expected_message)
+                         }
 
       subject.publish_to_channel(channel, message: message)
     end
@@ -71,7 +76,7 @@ describe DispatchRider::NotificationServices::Base do
     end
 
     it "returns an array of channels" do
-      subject.channels(:foo).should eq([channel])
+      expect(subject.channels(:foo)).to eq([channel])
     end
   end
 end

data/spec/lib/dispatch-rider/notification_services/file_system/channel_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe DispatchRider::NotificationServices::FileSystem::Channel do
-
   let(:path) { File.expand_path("tmp/test/channel") }
   let(:published_message) { File.new(Dir["#{path}/*.ready"].first).read }
 
@@ -11,7 +10,7 @@ describe DispatchRider::NotificationServices::FileSystem::Channel do
   subject { described_class.new(path) }
 
   describe "#publish" do
-    let(:message){ {:subject => "foo", :body => "bar"}.to_json }
+    let(:message) { { subject: "foo", body: "bar" }.to_json }
 
     it "adds a file to the path folder" do
       expect {
@@ -22,7 +21,7 @@ describe DispatchRider::NotificationServices::FileSystem::Channel do
     it "writes the message to the file" do
       subject.publish(message)
 
-      published_message.should == message
+      expect(published_message).to eq(message)
     end
   end
 end

data/spec/lib/dispatch-rider/notification_services/file_system/notifier_spec.rb

@@ -1,14 +1,12 @@
 require 'spec_helper'
 
 describe DispatchRider::NotificationServices::FileSystem::Notifier do
-
   subject { described_class.new({}) }
 
   describe "#channel" do
     it "returns a channel object" do
-      subject.channel("tmp/some/path").should be_a(DispatchRider::NotificationServices::FileSystem::Channel)
+      expect(subject.channel("tmp/some/path")).to be_a(DispatchRider::NotificationServices::FileSystem::Channel)
     end
   end
-
 end
 

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

@@ -1,23 +1,22 @@
 require 'spec_helper'
 
 describe DispatchRider::NotificationServices::FileSystem do
-
   describe "#notifier_builder" do
     it "returns the notifier builder" do
-      subject.notifier_builder.should eq(DispatchRider::NotificationServices::FileSystem::Notifier)
+      expect(subject.notifier_builder).to eq(DispatchRider::NotificationServices::FileSystem::Notifier)
     end
   end
 
   describe "#channel_registrar_builder" do
     it "returns the channel registrar builder" do
-      subject.channel_registrar_builder.should eq(DispatchRider::Registrars::FileSystemChannel)
+      expect(subject.channel_registrar_builder).to eq(DispatchRider::Registrars::FileSystemChannel)
     end
   end
 
   describe "#channel" do
     it "returns the channel" do
       subject.channel_registrar.register(:foo, :path => "tmp/test/channel")
-      subject.channel(:foo).should be_a(DispatchRider::NotificationServices::FileSystem::Channel)
+      expect(subject.channel(:foo)).to be_a(DispatchRider::NotificationServices::FileSystem::Channel)
     end
   end
 end

data/spec/lib/dispatch-rider/publisher/configuration/destination_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
-require 'rspec/its'
 
 describe DispatchRider::Publisher::Configuration::Destination do
-
   let(:attributes) do
     {
       "service" => "aws_sns",
@@ -19,43 +17,55 @@ describe DispatchRider::Publisher::Configuration::Destination do
     }
   end
 
-  subject{ described_class.new("employee", attributes) }
+  subject { described_class.new("employee", attributes) }
 
   describe "#name" do
-    its(:name) { is_expected.to eq("employee") }
+    describe '#name' do
+      subject { super().name }
+      it { is_expected.to eq("employee") }
+    end
   end
 
   describe "#service" do
-    its(:service) { is_expected.to eq("aws_sns") }
+    describe '#service' do
+      subject { super().service }
+      it { is_expected.to eq("aws_sns") }
+    end
   end
 
   describe "#channel" do
-    its(:channel) { is_expected.to eq("employee_updates") }
+    describe '#channel' do
+      subject { super().channel }
+      it { is_expected.to eq("employee_updates") }
+    end
   end
 
   describe "#options" do
-    its(:options) { is_expected.to eq(options) }
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to eq(options) }
+    end
   end
 
   describe "#==" do
-    let(:other){ described_class.new(name, other_attributes) }
+    let(:other) { described_class.new(name, other_attributes) }
 
     context "when the destinations' name, service, channel and options are the same" do
-      let(:name){ subject.name }
-      let(:other_attributes){ attributes }
+      let(:name) { subject.name }
+      let(:other_attributes) { attributes }
 
-      it{ should eq other }
+      it { is_expected.to eq other }
     end
 
     context "when the destinations' name is different" do
-      let(:name){ "account" }
-      let(:other_attributes){ attributes }
+      let(:name) { "account" }
+      let(:other_attributes) { attributes }
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
 
     context "when the destinations' service is different" do
-      let(:name){ subject.name }
+      let(:name) { subject.name }
 
       let(:other_attributes) do
         {
@@ -65,11 +75,11 @@ describe DispatchRider::Publisher::Configuration::Destination do
         }
       end
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
 
     context "when the destinations' channel is different" do
-      let(:name){ subject.name }
+      let(:name) { subject.name }
 
       let(:other_attributes) do
         {
@@ -79,11 +89,11 @@ describe DispatchRider::Publisher::Configuration::Destination do
         }
       end
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
 
     context "when the destinations' options are different" do
-      let(:name){ subject.name }
+      let(:name) { subject.name }
 
       let(:other_attributes) do
         {
@@ -93,8 +103,7 @@ describe DispatchRider::Publisher::Configuration::Destination do
         }
       end
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
   end
-
 end

data/spec/lib/dispatch-rider/publisher/configuration/notification_service_spec.rb

@@ -8,45 +8,51 @@ describe DispatchRider::Publisher::Configuration::NotificationService do
     }
   end
 
-  subject{ described_class.new("file_system", options) }
+  subject { described_class.new("file_system", options) }
 
   describe "#name" do
-    its(:name){ should == "file_system" }
+    describe '#name' do
+      subject { super().name }
+      it { is_expected.to eq("file_system") }
+    end
   end
 
   describe "#options" do
-    its(:options){ should == options }
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to eq(options) }
+    end
   end
 
   describe "#==" do
-    let(:other){ described_class.new(name, other_options) }
+    let(:other) { described_class.new(name, other_options) }
 
     context "two notification services with the same name and options" do
-      let(:name){ subject.name }
-      let(:other_options){ options }
+      let(:name) { subject.name }
+      let(:other_options) { options }
 
-      it{ should eq other }
+      it { is_expected.to eq other }
     end
 
     context "two notification services with different names but the same options" do
-      let(:name){ "aws_sns" }
-      let(:other_options){ options }
+      let(:name) { "aws_sns" }
+      let(:other_options) { options }
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
 
     context "two notificaiton services with the same name but different options" do
-      let(:name){ subject.name }
-      let(:other_options){ { "topic" => "employee_updates" } }
+      let(:name) { subject.name }
+      let(:other_options) { { "topic" => "employee_updates" } }
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
 
     context "two notification services with different names and options" do
-      let(:name){ "aws_sns" }
-      let(:other_options){ { "topic" => "employee_updates" } }
+      let(:name) { "aws_sns" }
+      let(:other_options) { { "topic" => "employee_updates" } }
 
-      it{ should_not eq other }
+      it { is_expected.not_to eq other }
     end
   end