qs 0.5.0 → 0.6.0

data/test/unit/event_handler_tests.rb

@@ -1,18 +1,30 @@
 require 'assert'
 require 'qs/event_handler'
 
-require 'qs/event'
+require 'much-plugin'
+require 'qs'
 require 'qs/message_handler'
+require 'qs/test_runner'
 
 module Qs::EventHandler
 
   class UnitTests < Assert::Context
+    include Qs::EventHandler::TestHelpers
+
     desc "Qs::EventHandler"
     setup do
+      Qs.init
       @handler_class = Class.new{ include Qs::EventHandler }
     end
+    teardown do
+      Qs.reset!
+    end
     subject{ @handler_class }
 
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Qs::Worker
+    end
+
     should "be a message handler" do
       assert_includes Qs::MessageHandler, subject
     end
@@ -22,42 +34,63 @@ module Qs::EventHandler
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner  = FakeRunner.new
-      @handler = TestEventHandler.new(@runner)
+      @event   = Factory.event
+      @runner  = test_runner(TestEventHandler, :message => @event)
+      @handler = @runner.handler
     end
     subject{ @handler }
 
-    should "know its event, channel, name and published at" do
-      assert_equal @runner.message,                   subject.public_event
-      assert_equal subject.public_event.channel,      subject.public_event_channel
-      assert_equal subject.public_event.name,         subject.public_event_name
-      assert_equal subject.public_event.published_at, subject.public_event_published_at
+    should "have private helpers for accessing event attrs" do
+      assert_equal @event,              subject.instance_eval{ event }
+      assert_equal @event.channel,      subject.instance_eval{ event_channel }
+      assert_equal @event.name,         subject.instance_eval{ event_name }
+      assert_equal @event.published_at, subject.instance_eval{ event_published_at }
     end
 
-    should "have a custom inspect" do
-      reference = '0x0%x' % (subject.object_id << 1)
-      expected = "#<#{subject.class}:#{reference} " \
-                 "@event=#{@handler.public_event.inspect}>"
-      assert_equal expected, subject.inspect
+  end
+
+  class TestHelpersTests < UnitTests
+    desc "TestHelpers"
+    setup do
+      Qs.init
+      event = Factory.event
+      @args = {
+        :message => event,
+        :params  => event.params
+      }
+
+      context_class = Class.new{ include Qs::EventHandler::TestHelpers }
+      @context = context_class.new
     end
+    teardown do
+      Qs.reset!
+    end
+    subject{ @context }
 
-  end
+    should have_imeths :test_runner, :test_handler
 
-  class TestEventHandler
-    include Qs::EventHandler
+    should "build a test runner for a given handler class" do
+      runner = subject.test_runner(@handler_class, @args)
 
-    def public_event;              event;              end
-    def public_event_channel;      event_channel;      end
-    def public_event_name;         event_name;         end
-    def public_event_published_at; event_published_at; end
-  end
+      assert_kind_of Qs::TestRunner, runner
+      assert_equal @handler_class,   runner.handler_class
+      assert_equal @args[:message],  runner.message
+      assert_equal @args[:params],   runner.params
+    end
 
-  class FakeRunner
-    attr_accessor :message
+    should "return an initialized handler instance" do
+      handler = subject.test_handler(@handler_class, @args)
+      assert_kind_of @handler_class, handler
 
-    def initialize
-      @message = Factory.event
+      exp = subject.test_runner(@handler_class, @args).handler
+      assert_equal exp, handler
     end
+
+  end
+
+  class TestEventHandler
+    include Qs::EventHandler
+
   end
 
 end

data/test/unit/job_handler_tests.rb

@@ -1,17 +1,30 @@
 require 'assert'
 require 'qs/job_handler'
 
+require 'much-plugin'
+require 'qs'
 require 'qs/message_handler'
+require 'qs/test_runner'
 
 module Qs::JobHandler
 
   class UnitTests < Assert::Context
+    include Qs::JobHandler::TestHelpers
+
     desc "Qs::JobHandler"
     setup do
+      Qs.init
       @handler_class = Class.new{ include Qs::JobHandler }
     end
+    teardown do
+      Qs.reset!
+    end
     subject{ @handler_class }
 
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Qs::Worker
+    end
+
     should "be a message handler" do
       assert_includes Qs::MessageHandler, subject
     end
@@ -21,40 +34,62 @@ module Qs::JobHandler
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner  = FakeRunner.new
-      @handler = TestJobHandler.new(@runner)
+      @job     = Factory.job
+      @runner  = test_runner(TestJobHandler, :message => @job)
+      @handler = @runner.handler
     end
     subject{ @handler }
 
-    should "know its job, job name and job created at" do
-      assert_equal @runner.message,               subject.public_job
-      assert_equal subject.public_job.name,       subject.public_job_name
-      assert_equal subject.public_job.created_at, subject.public_job_created_at
+    should "have private helpers for accessing job attrs" do
+      assert_equal @job,            subject.instance_eval{ job }
+      assert_equal @job.name,       subject.instance_eval{ job_name }
+      assert_equal @job.created_at, subject.instance_eval{ job_created_at }
     end
 
-    should "have a custom inspect" do
-      reference = '0x0%x' % (subject.object_id << 1)
-      exp = "#<#{subject.class}:#{reference} " \
-            "@job=#{@handler.public_job.inspect}>"
-      assert_equal exp, subject.inspect
+  end
+
+  class TestHelpersTests < UnitTests
+    desc "TestHelpers"
+    setup do
+      Qs.init
+      job = Factory.job
+      @args = {
+        :message => job,
+        :params  => job.params
+      }
+
+      context_class = Class.new{ include Qs::JobHandler::TestHelpers }
+      @context = context_class.new
     end
+    teardown do
+      Qs.reset!
+    end
+    subject{ @context }
 
-  end
+    should have_imeths :test_runner, :test_handler
 
-  class TestJobHandler
-    include Qs::JobHandler
+    should "build a test runner for a given handler class" do
+      runner = subject.test_runner(@handler_class, @args)
 
-    def public_job;            job;            end
-    def public_job_name;       job_name;       end
-    def public_job_created_at; job_created_at; end
-  end
+      assert_kind_of Qs::TestRunner, runner
+      assert_equal @handler_class,   runner.handler_class
+      assert_equal @args[:message],  runner.message
+      assert_equal @args[:params],   runner.params
+    end
 
-  class FakeRunner
-    attr_accessor :message
+    should "return an initialized handler instance" do
+      handler = subject.test_handler(@handler_class, @args)
+      assert_kind_of @handler_class, handler
 
-    def initialize
-      @message = Factory.job
+      exp = subject.test_runner(@handler_class, @args).handler
+      assert_equal exp, handler
     end
+
+  end
+
+  class TestJobHandler
+    include Qs::JobHandler
+
   end
 
 end

data/test/unit/message_handler_tests.rb

@@ -1,13 +1,22 @@
 require 'assert'
 require 'qs/message_handler'
 
+require 'much-plugin'
+require 'test/support/message_handler'
+
 module Qs::MessageHandler
 
   class UnitTests < Assert::Context
+    include Qs::MessageHandler::TestHelpers
+
     desc "Qs::MessageHandler"
     setup do
+      Qs.init
       @handler_class = Class.new{ include Qs::MessageHandler }
     end
+    teardown do
+      Qs.reset!
+    end
     subject{ @handler_class }
 
     should have_imeths :timeout
@@ -21,6 +30,10 @@ module Qs::MessageHandler
     should have_imeths :prepend_before_init, :prepend_after_init
     should have_imeths :prepend_before_run,  :prepend_after_run
 
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Qs::Worker
+    end
+
     should "allow reading/writing its timeout" do
       assert_nil subject.timeout
       value = Factory.integer
@@ -147,20 +160,20 @@ module Qs::MessageHandler
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner  = FakeRunner.new
-      @handler = TestMessageHandler.new(@runner)
+      @runner  = test_runner(TestMessageHandler)
+      @handler = @runner.handler
     end
     subject{ @handler }
 
-    should have_imeths :init, :init!, :run, :run!
+    should have_imeths :qs_init, :init!, :qs_run, :run!
+    should have_imeths :qs_run_callback
 
     should "know its params and logger" do
-      assert_equal @runner.params, subject.public_params
       assert_equal @runner.logger, subject.public_logger
+      assert_equal @runner.params, subject.public_params
     end
 
-    should "call `init!` and its before/after init callbacks using `init`" do
-      subject.init
+    should "have called `init!` and its before/after init callbacks" do
       assert_equal 1, subject.first_before_init_call_order
       assert_equal 2, subject.second_before_init_call_order
       assert_equal 3, subject.init_call_order
@@ -168,17 +181,65 @@ module Qs::MessageHandler
       assert_equal 5, subject.second_after_init_call_order
     end
 
-    should "call `run!` and its before/after run callbacks using `run`" do
-      subject.run
-      assert_equal 1, subject.first_before_run_call_order
-      assert_equal 2, subject.second_before_run_call_order
-      assert_equal 3, subject.run_call_order
-      assert_equal 4, subject.first_after_run_call_order
-      assert_equal 5, subject.second_after_run_call_order
+    should "not have called `run!` and its before/after run callbacks" do
+      assert_nil subject.first_before_run_call_order
+      assert_nil subject.second_before_run_call_order
+      assert_nil subject.run_call_order
+      assert_nil subject.first_after_run_call_order
+      assert_nil subject.second_after_run_call_order
+    end
+
+    should "run its callbacks with `qs_run_callback`" do
+      subject.qs_run_callback 'before_run'
+      assert_equal 6, subject.first_before_run_call_order
+      assert_equal 7, subject.second_before_run_call_order
+    end
+
+    should "know if it is equal to another message handler" do
+      handler = TestMessageHandler.new(@runner)
+      assert_equal handler, subject
+
+      handler = Class.new{ include Qs::MessageHandler }.new(Factory.string)
+      assert_not_equal handler, subject
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @handler.qs_run
+    end
+
+    should "call `run!` and it's callbacks" do
+      assert_equal 6,  subject.first_before_run_call_order
+      assert_equal 7,  subject.second_before_run_call_order
+      assert_equal 8,  subject.run_call_order
+      assert_equal 9,  subject.first_after_run_call_order
+      assert_equal 10, subject.second_after_run_call_order
+    end
+
+  end
+
+  class PrivateHelpersTests < InitTests
+    setup do
+      @something = Factory.string
+    end
+
+    should "call to the runner for its logger" do
+      stub_runner_with_something_for(:logger)
+      assert_equal @runner.logger, subject.instance_eval{ logger }
     end
 
-    should "raise a not implemented error when `run!` by default" do
-      assert_raises(NotImplementedError){ @handler_class.new(@runner).run! }
+    should "call to the runner for its params" do
+      stub_runner_with_something_for(:params)
+      assert_equal @runner.params, subject.instance_eval{ params }
+    end
+
+    private
+
+    def stub_runner_with_something_for(meth)
+      Assert.stub(@runner, meth){ @something }
     end
 
   end
@@ -223,13 +284,4 @@ module Qs::MessageHandler
     end
   end
 
-  class FakeRunner
-    attr_accessor :params, :logger
-
-    def initialize
-      @params = Factory.string
-      @logger = Factory.string
-    end
-  end
-
 end

data/test/unit/payload_handler_tests.rb

@@ -142,21 +142,6 @@ class Qs::PayloadHandler
 
   end
 
-  class RunWithExceptionWhileDebuggingTests < RunWithExceptionSetupTests
-    desc "and run with an exception"
-    setup do
-      ENV['QS_DEBUG'] = '1'
-    end
-    teardown do
-      ENV.delete('QS_DEBUG')
-    end
-
-    should "raise the exception" do
-      assert_raises(@route_exception.class){ @payload_handler.run }
-    end
-
-  end
-
   class LoggingJobSetupTests < InitSetupTests
     desc "and run with a job queue item"
     setup do
@@ -210,9 +195,11 @@ class Qs::PayloadHandler
     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}"
+      exp = "[Qs] #{exception.class}: #{exception.message}"
       assert_equal exp, logger_spy.verbose.error_logged.first
+      exception.backtrace.each do |l|
+        assert_includes "[Qs] #{l}", logger_spy.verbose.error_logged
+      end
 
       exp = JobSummaryLine.new(@job, {
         'time'    => @queue_item.time_taken,
@@ -282,9 +269,11 @@ class Qs::PayloadHandler
     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}"
+      exp = "[Qs] #{exception.class}: #{exception.message}"
       assert_equal exp, logger_spy.verbose.error_logged.first
+      exception.backtrace.each do |l|
+        assert_includes "[Qs] #{l}", logger_spy.verbose.error_logged
+      end
 
       exp = EventSummaryLine.new(@event, {
         'time'    => @queue_item.time_taken,
@@ -320,9 +309,11 @@ class Qs::PayloadHandler
 
       logger_spy = subject.logger
       exception = @queue_item.exception
-      backtrace = exception.backtrace.join("\n")
-      exp = "[Qs] #{exception.class}: #{exception.message}\n#{backtrace}"
+      exp = "[Qs] #{exception.class}: #{exception.message}"
       assert_equal exp, logger_spy.verbose.error_logged.first
+      exception.backtrace.each do |l|
+        assert_includes "[Qs] #{l}", logger_spy.verbose.error_logged
+      end
 
       exp = UnknownSummaryLine.new({
         'time'    => @queue_item.time_taken,

data/test/unit/qs_runner_tests.rb

@@ -10,7 +10,8 @@ class Qs::QsRunner
     desc "Qs::QsRunner"
     setup do
       Qs.config.timeout = Factory.integer
-      @runner_class = Qs::QsRunner
+      @handler_class = TestMessageHandler
+      @runner_class  = Qs::QsRunner
     end
     teardown do
       Qs.reset!
@@ -27,7 +28,6 @@ class Qs::QsRunner
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @handler_class = TestMessageHandler
       @runner = @runner_class.new(@handler_class)
     end
     subject{ @runner }
@@ -66,17 +66,17 @@ class Qs::QsRunner
       assert_equal [@runner.timeout], @timeout_called_with
     end
 
-    should "run the handlers before callbacks" do
+    should "run the handler's before callbacks" do
       assert_equal 1, @handler.first_before_call_order
       assert_equal 2, @handler.second_before_call_order
     end
 
-    should "call the handlers init and run methods" do
+    should "call the handler's init and run methods" do
       assert_equal 3, @handler.init_call_order
       assert_equal 4, @handler.run_call_order
     end
 
-    should "run the handlers after callbacks" do
+    should "run the handler's after callbacks" do
       assert_equal 5, @handler.first_after_call_order
       assert_equal 6, @handler.second_after_call_order
     end
@@ -157,10 +157,8 @@ class Qs::QsRunner
 
     private
 
-    def next_call_order
-      @order ||= 0
-      @order += 1
-    end
+    def next_call_order; @order ||= 0; @order += 1; end
+
   end
 
 end

data/test/unit/runner_tests.rb

@@ -24,7 +24,7 @@ class Qs::Runner
     subject{ @runner }
 
     should have_readers :handler_class, :handler
-    should have_readers :message, :params, :logger
+    should have_readers :logger, :message, :params
     should have_imeths :run
 
     should "know its handler class and handler" do
@@ -32,25 +32,27 @@ class Qs::Runner
       assert_instance_of @handler_class, subject.handler
     end
 
-    should "not set its message, params or logger by default" do
+    should "default its attrs" do
+      assert_instance_of Qs::NullLogger, subject.logger
       assert_nil subject.message
       assert_equal({}, subject.params)
-      assert_instance_of Qs::NullLogger, subject.logger
     end
 
-    should "allow passing a message, params and logger" do
+    should "know its attrs" do
       args = {
+        :logger  => Factory.string,
         :message => Factory.string,
-        :params  => Factory.string,
-        :logger  => Factory.string
+        :params  => Factory.string
       }
+
       runner = @runner_class.new(@handler_class, args)
+
+      assert_equal args[:logger],  runner.logger
       assert_equal args[:message], runner.message
       assert_equal args[:params],  runner.params
-      assert_equal args[:logger],  runner.logger
     end
 
-    should "raise a not implemented error when run" do
+    should "not implement its run method" do
       assert_raises(NotImplementedError){ subject.run }
     end
 
@@ -58,6 +60,7 @@ class Qs::Runner
 
   class TestJobHandler
     include Qs::JobHandler
+
   end
 
 end

data/test/unit/test_runner_tests.rb

@@ -28,10 +28,10 @@ class Qs::TestRunner
     setup do
       @handler_class = TestMessageHandler
       @args = {
-        :message => Factory.message,
-        :params  => { Factory.string => Factory.string },
-        :logger  => Factory.string,
-        :flag    => Factory.boolean
+        :logger       => Factory.string,
+        :message      => Factory.message,
+        :params       => { Factory.string => Factory.string },
+        :custom_value => Factory.integer
       }
       @original_args = @args.dup
       @runner  = @runner_class.new(@handler_class, @args)
@@ -41,33 +41,33 @@ class Qs::TestRunner
 
     should have_imeths :run
 
-    should "know its message, params and logger" do
+    should "know its standard args" do
+      assert_equal @args[:logger],  subject.logger
       assert_equal @args[:message], subject.message
       assert_equal @args[:params],  subject.params
-      assert_equal @args[:logger],  subject.logger
     end
 
-    should "write extra args to its message handler" do
-      assert_equal @args[:flag], @handler.flag
+    should "write any non-standard args to its handler" do
+      assert_equal @args[:custom_value], @handler.custom_value
     end
 
     should "not alter the args passed to it" do
       assert_equal @original_args, @args
     end
 
-    should "not call its message handler's before callbacks" do
+    should "not call its handler's before callbacks" do
       assert_nil @handler.before_called
     end
 
-    should "call its message handler's init" do
+    should "call its handler's init" do
       assert_true @handler.init_called
     end
 
-    should "not run its message handler" do
+    should "not call its handler's run" do
       assert_nil @handler.run_called
     end
 
-    should "not call its message handler's after callbacks" do
+    should "not call its handler's after callbacks" do
       assert_nil @handler.after_called
     end
 
@@ -194,7 +194,7 @@ class Qs::TestRunner
 
     attr_reader :before_called, :after_called
     attr_reader :init_called, :run_called
-    attr_accessor :flag
+    attr_accessor :custom_value
 
     before{ @before_called = true }
     after{ @after_called = true }
@@ -206,6 +206,7 @@ class Qs::TestRunner
     def run!
       @run_called = true
     end
+
   end
 
   class TestJobHandler