qs 0.3.0 → 0.4.0

data/test/unit/payload_handler_tests.rb

@@ -2,8 +2,7 @@ require 'assert'
 require 'qs/payload_handler'
 
 require 'qs/daemon_data'
-require 'qs/job'
-require 'qs/redis_item'
+require 'qs/queue_item'
 
 class Qs::PayloadHandler
 
@@ -17,31 +16,38 @@ class Qs::PayloadHandler
 
   end
 
-  class InitTests < UnitTests
+  class InitSetupTests < UnitTests
     desc "when init"
-    setup do
-      @route_spy = RouteSpy.new
+    subject{ @payload_handler }
+
+    def setup_for_message(message)
+      @route_spy   = RouteSpy.new(message.route_id)
       @daemon_data = Qs::DaemonData.new({
         :logger => Qs::NullLogger.new,
         :routes => [@route_spy]
       })
-      @job = Qs::Job.new(@route_spy.name, Factory.string => Factory.string)
-      serialized_payload = Qs.serialize(@job.to_payload)
-      @redis_item = Qs::RedisItem.new(Factory.string, serialized_payload)
+      encoded_payload = Qs::Payload.serialize(message)
+      @queue_item = Qs::QueueItem.new(Factory.string, encoded_payload)
 
       Assert.stub(Qs::Logger, :new){ |*args| QsLoggerSpy.new(*args) }
+    end
 
-      @payload_handler = @handler_class.new(@daemon_data, @redis_item)
+  end
+
+  class InitTests < InitSetupTests
+    setup do
+      @message = Factory.message
+      setup_for_message(@message)
+      @payload_handler = @handler_class.new(@daemon_data, @queue_item)
     end
-    subject{ @payload_handler }
 
-    should have_readers :daemon_data, :redis_item
+    should have_readers :daemon_data, :queue_item
     should have_readers :logger
     should have_imeths :run
 
-    should "know its daemon data, redis item and logger" do
+    should "know its daemon data, queue item and logger" do
       assert_equal @daemon_data, subject.daemon_data
-      assert_equal @redis_item,  subject.redis_item
+      assert_equal @queue_item,  subject.queue_item
       assert_equal @daemon_data.logger, subject.logger.passed_logger
       assert_equal @daemon_data.verbose_logging, subject.logger.verbose_logging
     end
@@ -54,42 +60,17 @@ class Qs::PayloadHandler
       @payload_handler.run
     end
 
-    should "run a route for the redis item" do
+    should "run a route for the queue item" do
       assert_true @route_spy.run_called
-      assert_equal @job, @route_spy.job_passed_to_run
+      assert_equal @message, @route_spy.message_passed_to_run
       assert_equal @daemon_data, @route_spy.daemon_data_passed_to_run
     end
 
-    should "build up its redis item as it processes it" do
-      assert_equal @job, @redis_item.job
-      assert_equal @route_spy.handler_class, @redis_item.handler_class
-      assert_nil @redis_item.exception
-      assert_instance_of Float, @redis_item.time_taken
-    end
-
-    should "log its processing of the redis item" do
-      logger_spy = subject.logger
-      expected = "[Qs] ===== Running job ====="
-      assert_includes expected, logger_spy.verbose.info_logged
-      expected = "[Qs]   Job:     #{@redis_item.job.name.inspect}"
-      assert_includes expected, logger_spy.verbose.info_logged
-      expected = "[Qs]   Params:  #{@redis_item.job.params.inspect}"
-      assert_includes expected, logger_spy.verbose.info_logged
-      expected = "[Qs]   Handler: #{@redis_item.handler_class}"
-      assert_includes expected, logger_spy.verbose.info_logged
-      expected = "[Qs] ===== Completed in #{@redis_item.time_taken}ms ====="
-      assert_includes expected, logger_spy.verbose.info_logged
-      assert_empty logger_spy.verbose.error_logged
-
-      expected = SummaryLine.new({
-        'time'    => @redis_item.time_taken,
-        'handler' => @redis_item.handler_class,
-        'job'     => @redis_item.job.name,
-        'params'  => @redis_item.job.params
-      })
-      assert_equal 1, logger_spy.summary.info_logged.size
-      assert_equal "[Qs] #{expected}", logger_spy.summary.info_logged.first
-      assert_empty logger_spy.summary.error_logged
+    should "build up its queue item as it processes it" do
+      assert_equal @message, @queue_item.message
+      assert_equal @route_spy.handler_class, @queue_item.handler_class
+      assert_nil @queue_item.exception
+      assert_instance_of Float, @queue_item.time_taken
     end
 
   end
@@ -114,26 +95,18 @@ class Qs::PayloadHandler
     should "run an error handler" do
       assert_equal @route_exception, @error_handler_spy.passed_exception
       exp = {
-        :daemon_data        => @daemon_data,
-        :queue_redis_key    => @redis_item.queue_redis_key,
-        :serialized_payload => @redis_item.serialized_payload,
-        :job                => @redis_item.job,
-        :handler_class      => @redis_item.handler_class
+        :daemon_data     => @daemon_data,
+        :queue_redis_key => @queue_item.queue_redis_key,
+        :encoded_payload => @queue_item.encoded_payload,
+        :message         => @queue_item.message,
+        :handler_class   => @queue_item.handler_class
       }
       assert_equal exp, @error_handler_spy.context_hash
       assert_true @error_handler_spy.run_called
     end
 
-    should "store the exception on the redis item" do
-      assert_equal @error_handler_spy.exception, @redis_item.exception
-    end
-
-    should "log its processing of the redis item" do
-      logger_spy = subject.logger
-      exception = @redis_item.exception
-      backtrace = exception.backtrace.join("\n")
-      exp = "[Qs] #{exception.class}: #{exception.message}\n#{backtrace}"
-      assert_equal exp, logger_spy.verbose.error_logged.first
+    should "store the exception on the queue item" do
+      assert_equal @error_handler_spy.exception, @queue_item.exception
     end
 
   end
@@ -145,8 +118,8 @@ class Qs::PayloadHandler
       Assert.stub(@route_spy, :run){ raise @shutdown_error }
     end
 
-    should "run an error handler if the redis item was started" do
-      Assert.stub(@redis_item, :started){ true }
+    should "run an error handler if the queue item was started" do
+      Assert.stub(@queue_item, :started){ true }
       assert_raises{ @payload_handler.run }
 
       passed_exception = @error_handler_spy.passed_exception
@@ -156,8 +129,8 @@ class Qs::PayloadHandler
       assert_true @error_handler_spy.run_called
     end
 
-    should "not run an error handler if the redis item was started" do
-      Assert.stub(@redis_item, :started){ false }
+    should "not run an error handler if the queue item was started" do
+      Assert.stub(@queue_item, :started){ false }
       assert_raises{ @payload_handler.run }
 
       assert_nil @error_handler_spy
@@ -184,39 +157,265 @@ class Qs::PayloadHandler
 
   end
 
-  class SummaryLineTests < UnitTests
-    desc "SummaryLine"
+  class LoggingJobSetupTests < InitSetupTests
+    desc "and run with a job queue item"
+    setup do
+      @job = Factory.job
+      setup_for_message(@job)
+      @payload_handler = @handler_class.new(@daemon_data, @queue_item)
+    end
+
+  end
+
+  class LoggingJobTests < LoggingJobSetupTests
+    setup do
+      @payload_handler.run
+    end
+
+    should "log its processing of the job queue item" do
+      logger_spy = subject.logger
+      exp = "[Qs] ===== Received message ====="
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Job:       #{@job.route_name.inspect}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Params:    #{@job.params.inspect}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Handler:   #{@queue_item.handler_class}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs] ===== Completed in #{@queue_item.time_taken}ms ====="
+      assert_includes exp, logger_spy.verbose.info_logged
+      assert_empty logger_spy.verbose.error_logged
+
+      exp = JobSummaryLine.new(@job, {
+        'time'    => @queue_item.time_taken,
+        'handler' => @queue_item.handler_class,
+        'params'  => @queue_item.message.params
+      })
+      assert_equal 1, logger_spy.summary.info_logged.size
+      assert_equal "[Qs] #{exp}", logger_spy.summary.info_logged.first
+      assert_empty logger_spy.summary.error_logged
+    end
+
+  end
+
+  class LoggingJobErrorTests < LoggingJobSetupTests
+    desc "that errors while being processed"
+    setup do
+      @route_exception = Factory.exception
+      Assert.stub(@route_spy, :run){ raise @route_exception }
+
+      @payload_handler.run
+    end
+
+    should "log the error" do
+      logger_spy = subject.logger
+      exception = @queue_item.exception
+      backtrace = exception.backtrace.join("\n")
+      exp = "[Qs] #{exception.class}: #{exception.message}\n#{backtrace}"
+      assert_equal exp, logger_spy.verbose.error_logged.first
+
+      exp = JobSummaryLine.new(@job, {
+        'time'    => @queue_item.time_taken,
+        'handler' => @queue_item.handler_class,
+        'params'  => @queue_item.message.params,
+        'error'   => "#{exception.class}: #{exception.message}"
+      })
+      assert_equal 1, logger_spy.summary.info_logged.size
+      assert_equal "[Qs] #{exp}", logger_spy.summary.info_logged.first
+      assert_empty logger_spy.summary.error_logged
+    end
+
+  end
+
+  class LoggingEventSetupTests < InitSetupTests
+    desc "and run with a event queue item"
+    setup do
+      @event = Factory.event
+      setup_for_message(@event)
+      @payload_handler = @handler_class.new(@daemon_data, @queue_item)
+    end
+
+  end
+
+  class LoggingEventTests < LoggingEventSetupTests
+    setup do
+      @payload_handler.run
+    end
+
+    should "log its processing of the event queue item" do
+      logger_spy = subject.logger
+      exp = "[Qs] ===== Received message ====="
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Event:     #{@event.route_name.inspect}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Publisher: #{@event.publisher.inspect}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Params:    #{@event.params.inspect}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs]   Handler:   #{@queue_item.handler_class}"
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs] ===== Completed in #{@queue_item.time_taken}ms ====="
+      assert_includes exp, logger_spy.verbose.info_logged
+      assert_empty logger_spy.verbose.error_logged
+
+      exp = EventSummaryLine.new(@event, {
+        'time'    => @queue_item.time_taken,
+        'handler' => @queue_item.handler_class,
+        'params'  => @queue_item.message.params
+      })
+      assert_equal 1, logger_spy.summary.info_logged.size
+      assert_equal "[Qs] #{exp}", logger_spy.summary.info_logged.first
+      assert_empty logger_spy.summary.error_logged
+    end
+
+  end
+
+  class LoggingEventErrorTests < LoggingEventSetupTests
+    desc "that errors while being processed"
+    setup do
+      @route_exception = Factory.exception
+      Assert.stub(@route_spy, :run){ raise @route_exception }
+
+      @payload_handler.run
+    end
+
+    should "log the error" do
+      logger_spy = subject.logger
+      exception = @queue_item.exception
+      backtrace = exception.backtrace.join("\n")
+      exp = "[Qs] #{exception.class}: #{exception.message}\n#{backtrace}"
+      assert_equal exp, logger_spy.verbose.error_logged.first
+
+      exp = EventSummaryLine.new(@event, {
+        'time'    => @queue_item.time_taken,
+        'handler' => @queue_item.handler_class,
+        'params'  => @queue_item.message.params,
+        'error'   => "#{exception.class}: #{exception.message}"
+      })
+      assert_equal 1, logger_spy.summary.info_logged.size
+      assert_equal "[Qs] #{exp}", logger_spy.summary.info_logged.first
+      assert_empty logger_spy.summary.error_logged
+    end
+
+  end
+
+  class LoggingUnknownTests < InitSetupTests
+    desc "and run with an unknown type of queue item"
+    setup do
+      @message = Factory.message
+      setup_for_message(@message)
+
+      Assert.stub(Qs::Payload, :deserialize){ raise Factory.exception }
+
+      @payload_handler = @handler_class.new(@daemon_data, @queue_item)
+      @payload_handler.run
+    end
+
+    should "log its processing of the job queue item" do
+      logger_spy = subject.logger
+      exp = "[Qs] ===== Received message ====="
+      assert_includes exp, logger_spy.verbose.info_logged
+      exp = "[Qs] ===== Completed in #{@queue_item.time_taken}ms ====="
+      assert_includes exp, logger_spy.verbose.info_logged
+
+      logger_spy = subject.logger
+      exception = @queue_item.exception
+      backtrace = exception.backtrace.join("\n")
+      exp = "[Qs] #{exception.class}: #{exception.message}\n#{backtrace}"
+      assert_equal exp, logger_spy.verbose.error_logged.first
+
+      exp = UnknownSummaryLine.new({
+        'time'    => @queue_item.time_taken,
+        'handler' => @queue_item.handler_class,
+        'error'   => "#{exception.class}: #{exception.message}"
+      })
+      assert_equal 1, logger_spy.summary.info_logged.size
+      assert_equal "[Qs] #{exp}", logger_spy.summary.info_logged.first
+      assert_empty logger_spy.summary.error_logged
+    end
+
+  end
+
+  class UnknownSummaryLineTests < UnitTests
+    desc "UnknownSummaryLine"
+    setup do
+      @attrs = {
+       'time'    => Factory.integer,
+       'handler' => Factory.string,
+       'error'   => Factory.string
+      }
+      @summary_line = UnknownSummaryLine.new(@attrs)
+    end
+    subject{ @summary_line }
+
+    should "build an ordered string of the attributes with their values" do
+      exp = "time=#{@attrs['time'].inspect} " \
+            "handler=#{@attrs['handler'].inspect} " \
+            "error=#{@attrs['error'].inspect}"
+      assert_equal exp, subject
+    end
+
+  end
+
+  class JobSummaryLineTests < UnitTests
+    desc "JobSummaryLine"
+    setup do
+      @job = Factory.job
+      @attrs = {
+       'time'    => Factory.integer,
+       'handler' => Factory.string,
+       'params'  => { Factory.string => Factory.string },
+       'error'   => Factory.string
+      }
+      @summary_line = JobSummaryLine.new(@job, @attrs)
+    end
+    subject{ @summary_line }
+
+    should "build an ordered string of the attributes with their values" do
+      exp = "time=#{@attrs['time'].inspect} " \
+            "handler=#{@attrs['handler'].inspect} " \
+            "job=#{@job.route_name.inspect} " \
+            "params=#{@attrs['params'].inspect} " \
+            "error=#{@attrs['error'].inspect}"
+      assert_equal exp, subject
+    end
+
+  end
+
+  class EventSummaryLineTests < UnitTests
+    desc "EventSummaryLine"
     setup do
+      @event = Factory.event(:publisher => Factory.string)
       @attrs = {
-        'time'    => Factory.string,
-        'handler' => Factory.string,
-        'job'     => Factory.string,
-        'params'  => Factory.string,
-        'error'   => Factory.string
+       'time'    => Factory.integer,
+       'handler' => Factory.string,
+       'params'  => { Factory.string => Factory.string },
+       'error'   => Factory.string
       }
-      @summary_line = SummaryLine.new(@attrs)
+      @summary_line = EventSummaryLine.new(@event, @attrs)
     end
     subject{ @summary_line }
 
-    should "build a string of all the attributes ordered with their values" do
-      expected = "time=#{@attrs['time'].inspect} " \
-                 "handler=#{@attrs['handler'].inspect} " \
-                 "job=#{@attrs['job'].inspect} " \
-                 "params=#{@attrs['params'].inspect} " \
-                 "error=#{@attrs['error'].inspect}"
-      assert_equal expected, subject
+    should "build an ordered string of the attributes with their values" do
+      exp = "time=#{@attrs['time'].inspect} " \
+            "handler=#{@attrs['handler'].inspect} " \
+            "event=#{@event.route_name.inspect} " \
+            "publisher=#{@event.publisher.inspect} " \
+            "params=#{@attrs['params'].inspect} " \
+            "error=#{@attrs['error'].inspect}"
+      assert_equal exp, subject
     end
 
   end
 
   class RouteSpy
-    attr_reader :name
-    attr_reader :job_passed_to_run, :daemon_data_passed_to_run
+    attr_reader :id
+    attr_reader :message_passed_to_run, :daemon_data_passed_to_run
     attr_reader :run_called
 
-    def initialize
-      @name = Factory.string
-      @job_passed_to_run = nil
+    def initialize(message_route_id)
+      @id = message_route_id
+      @message_passed_to_run = nil
       @daemon_data_passed_to_run = nil
       @run_called = false
     end
@@ -225,8 +424,8 @@ class Qs::PayloadHandler
       TestHandler
     end
 
-    def run(job, daemon_data)
-      @job_passed_to_run = job
+    def run(message, daemon_data)
+      @message_passed_to_run = message
       @daemon_data_passed_to_run = daemon_data
       @run_called = true
     end