dispatch-rider 1.5.3 → 1.6.0

data/spec/lib/dispatch-rider/callbacks/storage_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
 describe DispatchRider::Callbacks::Storage do
-
-  subject{ described_class.new }
+  subject { described_class.new }
 
   describe "adding callbacks" do
-
     let!(:log) { [] }
     let(:actual) { proc { log << :actual } }
 
@@ -17,7 +15,7 @@ describe DispatchRider::Callbacks::Storage do
           log << :aafter
         end
         subject.for(:initialize).first[actual]
-        log.should == [:abefore, :actual, :aafter]
+        expect(log).to eq [:abefore, :actual, :aafter]
       end
     end
 
@@ -25,7 +23,7 @@ describe DispatchRider::Callbacks::Storage do
       example do
         subject.before(:initialize) { log << :before }
         subject.for(:initialize).first[actual]
-        log.should == [:before, :actual]
+        expect(log).to eq [:before, :actual]
       end
     end
 
@@ -33,11 +31,8 @@ describe DispatchRider::Callbacks::Storage do
       example do
         subject.after(:initialize) { log << :after }
         subject.for(:initialize).first[actual]
-        log.should == [:actual, :after]
+        expect(log).to eq [:actual, :after]
       end
     end
-
   end
-
-
 end

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

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe DispatchRider::Configuration do
 
-  subject{ described_class.new }
+  subject { described_class.new }
 
   describe "defaults" do
     example do
       expect(subject.handler_path).to match_regex(/\/app\/handlers/)
       expect(subject.error_handler).to eq DispatchRider::DefaultErrorHandler
       expect(subject.queue_kind).to eq :file_system
-      expect(subject.queue_info).to eq({ path: "tmp/dispatch-rider-queue" })
+      expect(subject.queue_info).to eq(path: "tmp/dispatch-rider-queue")
       expect(subject.subscriber).to eq DispatchRider::Subscriber
     end
   end
@@ -47,7 +47,7 @@ describe DispatchRider::Configuration do
       subject.default_retry_timeout = 60
       expect(TestHandler.instance_methods).to include(:retry_timeout)
       #Need to do this so that all the other tests don't have this as default!
-      DispatchRider::Handlers::Base.send(:remove_method,:retry_timeout)
+      DispatchRider::Handlers::Base.send(:remove_method, :retry_timeout)
     end
   end
 

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

@@ -3,9 +3,9 @@ require "spec_helper"
 describe DispatchRider::DefaultErrorHandler do
 
   describe ".call" do
-    let(:exception){ Exception.new("Something went terribly wrong") }
+    let(:exception) { Exception.new("Something went terribly wrong") }
     example do
-      expect{
+      expect {
         described_class.call("Error", exception)
       }.to raise_exception exception
     end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe DispatchRider::Demultiplexer, :nodb => true do
+describe DispatchRider::Demultiplexer, nodb: true do
   class TestHandler < DispatchRider::Handlers::Base
     def process(options)
       raise "OMG!!!" if options["raise_exception"]
@@ -17,7 +17,7 @@ describe DispatchRider::Demultiplexer, :nodb => true do
     DispatchRider::QueueServices::Simple.new
   end
 
-  let(:message){ DispatchRider::Message.new(:subject => "test_handler", :body => {}) }
+  let(:message) { DispatchRider::Message.new(subject: "test_handler", body: {}) }
 
   let(:demultiplexer_thread) do
     demultiplexer
@@ -28,17 +28,17 @@ describe DispatchRider::Demultiplexer, :nodb => true do
     thread
   end
 
-  let(:error_handler){ ->(message, exception){ raise exception }}
+  let(:error_handler) { ->(_message, exception) { raise exception } }
 
   subject(:demultiplexer) { DispatchRider::Demultiplexer.new(queue, dispatcher, error_handler) }
 
   describe "#initialize" do
     it "should assign the queue" do
-      demultiplexer.queue.should be_empty
+      expect(demultiplexer.queue).to be_empty
     end
 
     it "should assign the dispatcher" do
-      demultiplexer.dispatcher.fetch(:test_handler).should eq(TestHandler)
+      expect(demultiplexer.dispatcher.fetch(:test_handler)).to eq(TestHandler)
     end
   end
 
@@ -55,7 +55,7 @@ describe DispatchRider::Demultiplexer, :nodb => true do
       end
 
       it "should be sending the message to the dispatcher" do
-        demultiplexer.should_receive(:dispatch_message).with(message).at_least(:once)
+        expect(demultiplexer).to receive(:dispatch_message).with(message).at_least(:once)
         demultiplexer_thread.run
         sleep 0.01 # give it a chance to process the job async before killing the demux
       end
@@ -63,7 +63,7 @@ describe DispatchRider::Demultiplexer, :nodb => true do
       # THIS ALSO TESTS THAT THE JOB IS NOT RUN MULTIPLE TIMES
       # IF THIS FAILS, BE CAREFUL NOT TO INTRODUCE BUGS
       it "should call the correct handler" do
-        TestHandler.any_instance.should_receive(:process).with(message.body).at_least(1).times
+        expect_any_instance_of(TestHandler).to receive(:process).with(message.body).at_least(1).times
         demultiplexer_thread.run
         sleep 0.01 # give it a chance to process the job async before killing the demux
       end
@@ -71,7 +71,7 @@ describe DispatchRider::Demultiplexer, :nodb => true do
 
     context "when the queue is empty" do
       it "should not be sending any message to the dispatcher" do
-        demultiplexer.should_receive(:dispatch_message).exactly(0).times
+        expect(demultiplexer).to receive(:dispatch_message).exactly(0).times
         demultiplexer_thread.run
       end
     end
@@ -83,8 +83,8 @@ describe DispatchRider::Demultiplexer, :nodb => true do
       end
 
       it "should call the error handler" do
-        error_handler.should_receive(:call).at_least(:once).and_return(true)
-        queue.should_not_receive(:delete)
+        expect(error_handler).to receive(:call).at_least(:once).and_return(true)
+        expect(queue).not_to receive(:delete)
         demultiplexer_thread.run
         sleep 0.01 # give it a chance to process the job async before killing the demux
       end
@@ -92,11 +92,11 @@ describe DispatchRider::Demultiplexer, :nodb => true do
 
     context "when the queue crashes" do
       before do
-        queue.stub(:pop){ raise "OMG!!!"}
+        allow(queue).to receive(:pop) { raise "OMG!!!" }
       end
 
       it "should call the error handler" do
-        error_handler.should_receive(:call).once
+        expect(error_handler).to receive(:call).once
         demultiplexer_thread.run
 
         sleep 0.01 # give it a chance to process the job async before killing the demux
@@ -107,10 +107,10 @@ describe DispatchRider::Demultiplexer, :nodb => true do
   describe ".stop" do
     it "should stop the demultiplexer" do
       demultiplexer_thread.run
-      demultiplexer_thread.should be_alive # looper should be looping
+      expect(demultiplexer_thread).to be_alive # looper should be looping
       demultiplexer_thread[:demultiplexer].stop
       demultiplexer_thread.join
-      demultiplexer_thread.should_not be_alive # looper should close the loop
+      expect(demultiplexer_thread).not_to be_alive # looper should close the loop
     end
   end
 

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

@@ -8,21 +8,21 @@ describe DispatchRider::Dispatcher, :nodb => true do
   end
 
   class HandlerThatReturnsFalse < DispatchRider::Handlers::Base
-    def process(params)
+    def process(_params)
       false
     end
   end
 
   describe "#dispatch" do
-    let(:message){ DispatchRider::Message.new(:subject => "handle_something", :body => { :do_throw_something => true }) }
+    let(:message) { DispatchRider::Message.new(subject: "handle_something", body: { do_throw_something: true }) }
 
     describe "callbacks" do
       let(:dummy) { double(:dummy) }
       let(:storage) { DispatchRider::Callbacks::Storage.new }
-      let(:message){ DispatchRider::Message.new(:subject => "handle_something", :body => { :do_throw_something => true }) }
+      let(:message) { DispatchRider::Message.new(subject: "handle_something", body: { do_throw_something: true }) }
 
       before do
-        DispatchRider.config.stub(:callbacks) { storage }
+        allow(DispatchRider.config).to receive(:callbacks) { storage }
         storage.around(:dispatch_message) do |block, message|
           begin
             dummy.before
@@ -35,9 +35,9 @@ describe DispatchRider::Dispatcher, :nodb => true do
         subject.register('handle_something')
       end
       example do
-        dummy.should_receive(:before).once
-        dummy.should_receive(:after).once
-        dummy.should_receive(:log).with(message).once
+        expect(dummy).to receive(:before).once
+        expect(dummy).to receive(:after).once
+        expect(dummy).to receive(:log).with(message).once
         catch(:something) do
           subject.dispatch(message)
         end
@@ -55,7 +55,9 @@ describe DispatchRider::Dispatcher, :nodb => true do
     end
 
     context "when the handler returns false" do
-      let(:message){ DispatchRider::Message.new(:subject => "handler_that_returns_false", :body => { :do_throw_something => true }) }
+      let(:message) do
+        DispatchRider::Message.new(subject: "handler_that_returns_false", body: { do_throw_something: true })
+      end
 
       before :each do
         subject.register('handler_that_returns_false')

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

@@ -5,32 +5,38 @@ describe DispatchRider::Handlers::Base do
   end
 
   class ProcessImplemented < DispatchRider::Handlers::Base
-    def process(options)
+    def process(_options)
       "good job"
     end
   end
-  
+
   class ProcessWithImmediateRetry < DispatchRider::Handlers::Base
-    def process(options)
+    def process(_options)
       raise "I have failed!"
     end
-    
-    def retry_timeout; :immediate; end
+
+    def retry_timeout
+      :immediate
+    end
   end
-  
+
   class ProcessWithTenSecondRetry < DispatchRider::Handlers::Base
-    def process(options)
+    def process(_options)
       raise "I have failed!"
     end
-    
-    def retry_timeout; 10*60; end
+
+    def retry_timeout
+      10 * 60
+    end
   end
 
   describe "#do_process" do
-    let(:message){ double(:message, subject: 'some_message', body: { 'guid' => DispatchRider::Debug::PUBLISHER_MESSAGE_GUID }) }
+    let(:message) do
+      double(:message, subject: 'some_message', body: { 'guid' => DispatchRider::Debug::PUBLISHER_MESSAGE_GUID })
+    end
 
     context "when class doesn't implement process" do
-      let(:handler){ NoProcessImplemented.new }
+      let(:handler) { NoProcessImplemented.new }
 
       example do
         expect {
@@ -40,7 +46,7 @@ describe DispatchRider::Handlers::Base do
     end
 
     context "when the class does implement process" do
-      let(:handler){ ProcessImplemented.new }
+      let(:handler) { ProcessImplemented.new }
 
       example do
         expect {
@@ -49,33 +55,32 @@ describe DispatchRider::Handlers::Base do
       end
 
       example do
-        handler.do_process(message).should == "good job"
+        expect(handler.do_process(message)).to eq("good job")
       end
     end
-    
+
     context "when the class wants to immediately retry" do
       let(:handler) { ProcessWithImmediateRetry.new }
-      
+
       example do
-        message.should_receive(:return_to_queue)
-        
+        expect(message).to receive(:return_to_queue)
+
         expect {
           handler.do_process(message)
         }.to raise_exception "I have failed!"
       end
     end
-    
+
     context "when the class wants to retry in 10 seconds" do
       let(:handler) { ProcessWithTenSecondRetry.new }
-      
+
       example do
-        message.should_receive(:extend_timeout).with(10*60)
-        
+        expect(message).to receive(:extend_timeout).with(10 * 60)
+
         expect {
           handler.do_process(message)
         }.to raise_exception "I have failed!"
       end
     end
   end
-
 end

data/spec/lib/dispatch-rider/handlers/inheritance_tracking_spec.rb

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
 describe DispatchRider::Handlers::InheritanceTracking do
-
   class InheritanceDummyClass
     extend DispatchRider::Handlers::InheritanceTracking
   end
 
   describe ".subclasses" do
     context "when a class inherits from the dummy class" do
-      class Blah < InheritanceDummyClass; end
+      class Blah < InheritanceDummyClass
+      end
 
       example do
-        InheritanceDummyClass.subclasses.should include(Blah)
+        expect(InheritanceDummyClass.subclasses).to include(Blah)
       end
 
       context "and another class inherits from the dummy class" do
-        class Foo < InheritanceDummyClass; end
+        class Foo < InheritanceDummyClass
+        end
 
         example do
-          InheritanceDummyClass.subclasses.should include(Blah, Foo)
+          expect(InheritanceDummyClass.subclasses).to include(Blah, Foo)
         end
       end
     end
   end
-
 end

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe DispatchRider::Logging::JsonFormatter 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(:exception) { StandardError.new }
+  let(:reason) { "Stop reason" }
+
+  let(:result_object) do
+    {
+      "subject" => "test",
+      "guid" => "123",
+      "body" => {
+        "key" => "value"
+      },
+    }
+  end
+  let(:result_exception) do
+    {
+      "expection" => {
+        "class" => "StandardError",
+        "message" => "StandardError"
+      }
+    }
+  end
+
+  context "format_error_handler_fail" do
+    let(:formatted_message) { result_object.merge("phase" => "failed").merge(result_exception) }
+    let(:result_message) { JSON.parse subject.format_error_handler_fail(message, exception) }
+
+    example { expect(result_message).to eq(formatted_message) }
+  end
+
+  context "format_got_stop" do
+    let(:formatted_message) { result_object.merge("phase" => "stop", "reason" => reason) }
+    let(:result_message) { JSON.parse subject.format_got_stop(message, reason) }
+
+    example { expect(result_message).to eq(formatted_message) }
+  end
+
+  context "format_handling" do
+    context "start" do
+      let(:formatted_message) { result_object.merge("phase" => "start") }
+      let(:result_message) { JSON.parse subject.format_handling(:start, message) }
+
+      example { expect(result_message).to eq(formatted_message) }
+    end
+
+    context "success" do
+      let(:formatted_message) { result_object.merge("phase" => "success") }
+      let(:result_message) { JSON.parse subject.format_handling(:success, message) }
+
+      example { expect(result_message).to eq(formatted_message) }
+    end
+
+    context "complete" do
+      let(:formatted_message) { result_object.merge("phase" => "complete", "duration" => "2.00") }
+      let(:result_message) { JSON.parse subject.format_handling(:complete, message, duration: 2.0) }
+
+      example { expect(result_message).to eq(formatted_message) }
+    end
+
+    context "fail" do
+      let(:formatted_message) { result_object.merge("phase" => "fail").merge(result_exception) }
+      let(:result_message) { JSON.parse subject.format_handling(:fail, message, exception: exception) }
+
+      example { expect(formatted_message).to eq(formatted_message) }
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe DispatchRider::Logging::LifecycleLogger do
+  subject { DispatchRider::Logging::LifecycleLogger }
+
+  let(:message) { DispatchRider::Message.new(subject: 'test', body: 'test_handler') }
+  let(:string_to_log) { "string to log" }
+  let(:exception) { StandardError.new }
+  let(:reason) { "Stop reason" }
+
+  let(:formatter) { DispatchRider.config.log_formatter }
+  let(:logger) { DispatchRider.config.logger }
+
+  before do
+    allow(formatter).to receive(:format_got_stop).and_return(string_to_log)
+    allow(formatter).to receive(:format_error_handler_fail).and_return(string_to_log)
+    allow(formatter).to receive(:format_handling).and_return(string_to_log)
+  end
+
+  context "log_error_handler_fail" do
+    after { subject.log_error_handler_fail message, exception }
+
+    it "calls logger with error" do
+      expect(logger).to receive(:error).with(string_to_log)
+    end
+  end
+
+  context "log_got_stop" do
+    after { subject.log_got_stop reason, message }
+
+    it "calls logger with info" do
+      expect(logger).to receive(:info).with(string_to_log)
+    end
+  end
+
+  context "wrap_handling" do
+    context "block runs successfully" do
+      let(:block) { Proc.new { true } }
+      after { subject.wrap_handling(message, &block) }
+
+      it "logs start" do
+        expect(subject).to receive(:log_start).with(message)
+      end
+
+      it "logs success" do
+        expect(subject).to receive(:log_success).with(message)
+      end
+
+      it "logs complete" do
+        expect(subject).to receive(:log_complete).with(message, an_instance_of(Float))
+      end
+    end
+
+    context "block fails" do
+      let(:block) { Proc.new { raise exception } }
+      after do
+        expect { subject.wrap_handling(message, &block) }.to raise_error(exception)
+      end
+
+      it "logs start" do
+        expect(subject).to receive(:log_start).with(message)
+      end
+
+      it "logs fail" do
+        expect(subject).to receive(:log_fail).with(message, exception)
+      end
+
+      it "logs complete" do
+        expect(subject).to receive(:log_complete).with(message, an_instance_of(Float))
+      end
+    end
+  end
+end