qs 0.0.1 → 0.1.0

data/test/unit/error_handler_tests.rb

@@ -0,0 +1,163 @@
+require 'assert'
+require 'qs/error_handler'
+
+require 'qs/daemon_data'
+require 'qs/queue'
+
+class Qs::ErrorHandler
+
+  class UnitTests < Assert::Context
+    desc "Qs::ErrorHandler"
+    setup do
+      @exception       = Factory.exception
+      @daemon_data     = Qs::DaemonData.new
+      @queue_name      = Factory.string
+      @queue_redis_key = Qs::Queue::RedisKey.new(@queue_name)
+      @context_hash    = {
+        :daemon_data        => @daemon_data,
+        :queue_redis_key    => @queue_redis_key,
+        :serialized_payload => Factory.string,
+        :job                => Factory.string,
+        :handler_class      => Factory.string
+      }
+
+      @handler_class = Qs::ErrorHandler
+    end
+    subject{ @handler_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @call_count = 0
+      @first_called_at = nil
+      @second_called_at = nil
+      @args_passed_to_error_proc = nil
+      first_error_proc = proc do |*args|
+        @args_passed_to_error_proc = args
+        @first_called_at = (@call_count += 1)
+      end
+      second_error_proc = proc{ @second_called_at = (@call_count += 1) }
+      Assert.stub(@daemon_data, :error_procs){ [first_error_proc, second_error_proc] }
+
+      @handler = @handler_class.new(@exception, @context_hash)
+    end
+    subject{ @handler }
+
+    should have_readers :exception, :context
+    should have_imeths :run
+
+    should "know its exception and context" do
+      assert_equal @exception, subject.exception
+      exp = Qs::ErrorContext.new(@context_hash)
+      assert_equal exp, subject.context
+    end
+
+    should "know its error procs" do
+      assert_equal @daemon_data.error_procs.reverse, subject.error_procs
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @handler.run
+    end
+
+    should "pass its exception and context to the error procs" do
+      assert_not_nil @args_passed_to_error_proc
+      assert_includes subject.exception, @args_passed_to_error_proc
+      assert_includes subject.context,   @args_passed_to_error_proc
+    end
+
+    should "call each of its error procs" do
+      assert_equal 1, @second_called_at
+      assert_equal 2, @first_called_at
+    end
+
+  end
+
+  class RunAndErrorProcThrowsExceptionTests < UnitTests
+    desc "run with an error proc that throws an exception"
+    setup do
+      @proc_exception = Factory.exception
+      error_proc = proc{ raise @proc_exception }
+      Assert.stub(@daemon_data, :error_procs){ [error_proc] }
+
+      @handler = @handler_class.new(@exception, @context_hash).tap(&:run)
+    end
+    subject{ @handler }
+
+    should "set its exception to the exception thrown by the error proc" do
+      assert_equal @proc_exception, subject.exception
+    end
+
+  end
+
+  class RunWithMultipleErrorProcsThatThrowExceptionsTests < UnitTests
+    desc "run with multiple error procs that throw an exception"
+    setup do
+      @first_caught_exception  = nil
+      @second_caught_exception = nil
+      @third_caught_exception  = nil
+
+      @third_proc_exception = Factory.exception
+      third_proc = proc do |exception, context|
+        @third_caught_exception = exception
+        raise @third_proc_exception
+      end
+
+      @second_proc_exception = Factory.exception
+      second_proc = proc do |exception, context|
+        @second_caught_exception = exception
+        raise @second_proc_exception
+      end
+
+      first_proc = proc{ |exception, context| @first_caught_exception = exception }
+
+      Assert.stub(@daemon_data, :error_procs){ [first_proc, second_proc, third_proc] }
+      @handler = @handler_class.new(@exception, @context_hash).tap(&:run)
+    end
+    subject{ @handler }
+
+    should "call each proc, passing the previously raised exception to the next" do
+      assert_equal @exception,             @third_caught_exception
+      assert_equal @third_proc_exception,  @second_caught_exception
+      assert_equal @second_proc_exception, @first_caught_exception
+    end
+
+  end
+
+  class ErrorContextTests < UnitTests
+    desc "ErrorContext"
+    setup do
+      @context = Qs::ErrorContext.new(@context_hash)
+    end
+    subject{ @context }
+
+    should have_readers :daemon_data
+    should have_readers :queue_name, :serialized_payload
+    should have_readers :job, :handler_class
+
+    should "know its attributes" do
+      assert_equal @context_hash[:daemon_data], subject.daemon_data
+      exp = Qs::Queue::RedisKey.parse_name(@context_hash[:queue_redis_key])
+      assert_equal exp, subject.queue_name
+      assert_equal @context_hash[:serialized_payload], subject.serialized_payload
+      assert_equal @context_hash[:job], subject.job
+      assert_equal @context_hash[:handler_class], subject.handler_class
+    end
+
+    should "know if it equals another context" do
+      exp = Qs::ErrorContext.new(@context_hash)
+      assert_equal exp, subject
+
+      exp = Qs::ErrorContext.new({})
+      assert_not_equal exp, subject
+    end
+
+  end
+
+end

data/test/unit/job_handler_tests.rb

@@ -0,0 +1,253 @@
+require 'assert'
+require 'qs/job_handler'
+
+module Qs::JobHandler
+
+  class UnitTests < Assert::Context
+    desc "Qs::JobHandler"
+    setup do
+      @handler_class = Class.new{ include Qs::JobHandler }
+    end
+    subject{ @handler_class }
+
+    should have_imeths :timeout
+    should have_imeths :before_callbacks, :after_callbacks
+    should have_imeths :before_init_callbacks, :after_init_callbacks
+    should have_imeths :before_run_callbacks,  :after_run_callbacks
+    should have_imeths :before, :after
+    should have_imeths :before_init, :after_init
+    should have_imeths :before_run,  :after_run
+    should have_imeths :prepend_before, :prepend_after
+    should have_imeths :prepend_before_init, :prepend_after_init
+    should have_imeths :prepend_before_run,  :prepend_after_run
+
+    should "allow reading/writing its timeout" do
+      assert_nil subject.timeout
+      value = Factory.integer
+      subject.timeout(value)
+      assert_equal value, subject.timeout
+    end
+
+    should "convert timeout values to floats" do
+      value = Factory.float.to_s
+      subject.timeout(value)
+      assert_equal value.to_f, subject.timeout
+    end
+
+    should "return an empty array by default using `before_callbacks`" do
+      assert_equal [], subject.before_callbacks
+    end
+
+    should "return an empty array by default using `after_callbacks`" do
+      assert_equal [], subject.after_callbacks
+    end
+
+    should "return an empty array by default using `before_init_callbacks`" do
+      assert_equal [], subject.before_init_callbacks
+    end
+
+    should "return an empty array by default using `after_init_callbacks`" do
+      assert_equal [], subject.after_init_callbacks
+    end
+
+    should "return an empty array by default using `before_run_callbacks`" do
+      assert_equal [], subject.before_run_callbacks
+    end
+
+    should "return an empty array by default using `after_run_callbacks`" do
+      assert_equal [], subject.after_run_callbacks
+    end
+
+    should "append a block to the before callbacks using `before`" do
+      subject.before_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.before(&block)
+      assert_equal block, subject.before_callbacks.last
+    end
+
+    should "append a block to the after callbacks using `after`" do
+      subject.after_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.after(&block)
+      assert_equal block, subject.after_callbacks.last
+    end
+
+    should "append a block to the before init callbacks using `before_init`" do
+      subject.before_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.before_init(&block)
+      assert_equal block, subject.before_init_callbacks.last
+    end
+
+    should "append a block to the after init callbacks using `after_init`" do
+      subject.after_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.after_init(&block)
+      assert_equal block, subject.after_init_callbacks.last
+    end
+
+    should "append a block to the before run callbacks using `before_run`" do
+      subject.before_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.before_run(&block)
+      assert_equal block, subject.before_run_callbacks.last
+    end
+
+    should "append a block to the after run callbacks using `after_run`" do
+      subject.after_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.after_run(&block)
+      assert_equal block, subject.after_run_callbacks.last
+    end
+
+    should "prepend a block to the before callbacks using `prepend_before`" do
+      subject.before_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_before(&block)
+      assert_equal block, subject.before_callbacks.first
+    end
+
+    should "prepend a block to the after callbacks using `prepend_after`" do
+      subject.after_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_after(&block)
+      assert_equal block, subject.after_callbacks.first
+    end
+
+    should "prepend a block to the before init callbacks using `prepend_before_init`" do
+      subject.before_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_before_init(&block)
+      assert_equal block, subject.before_init_callbacks.first
+    end
+
+    should "prepend a block to the after init callbacks using `prepend_after_init`" do
+      subject.after_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_after_init(&block)
+      assert_equal block, subject.after_init_callbacks.first
+    end
+
+    should "prepend a block to the before run callbacks using `prepend_before_run`" do
+      subject.before_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_before_run(&block)
+      assert_equal block, subject.before_run_callbacks.first
+    end
+
+    should "prepend a block to the after run callbacks using `prepend_after_run`" do
+      subject.after_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_after_run(&block)
+      assert_equal block, subject.after_run_callbacks.first
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @runner = FakeRunner.new
+      @handler = TestJobHandler.new(@runner)
+    end
+    subject{ @handler }
+
+    should have_imeths :init, :init!, :run, :run!
+
+    should "know its job, params and logger" do
+      assert_equal @runner.job,    subject.public_job
+      assert_equal @runner.params, subject.public_params
+      assert_equal @runner.logger, subject.public_logger
+    end
+
+    should "call `init!` and its before/after init callbacks using `init`" do
+      subject.init
+      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
+      assert_equal 4, subject.first_after_init_call_order
+      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
+    end
+
+    should "have a custom inspect" do
+      reference = '0x0%x' % (subject.object_id << 1)
+      expected = "#<#{subject.class}:#{reference} " \
+                 "@job=#{@runner.job.inspect}>"
+      assert_equal expected, subject.inspect
+    end
+
+    should "raise a not implemented error when `run!` by default" do
+      assert_raises(NotImplementedError){ @handler_class.new(@runner).run! }
+    end
+
+  end
+
+  class TestJobHandler
+    include Qs::JobHandler
+
+    attr_reader :first_before_init_call_order, :second_before_init_call_order
+    attr_reader :first_after_init_call_order, :second_after_init_call_order
+    attr_reader :first_before_run_call_order, :second_before_run_call_order
+    attr_reader :first_after_run_call_order, :second_after_run_call_order
+    attr_reader :init_call_order, :run_call_order
+
+    before_init{ @first_before_init_call_order = next_call_order }
+    before_init{ @second_before_init_call_order = next_call_order }
+
+    after_init{ @first_after_init_call_order = next_call_order }
+    after_init{ @second_after_init_call_order = next_call_order }
+
+    before_run{ @first_before_run_call_order = next_call_order }
+    before_run{ @second_before_run_call_order = next_call_order }
+
+    after_run{ @first_after_run_call_order = next_call_order }
+    after_run{ @second_after_run_call_order = next_call_order }
+
+    def init!
+      @init_call_order = next_call_order
+    end
+
+    def run!
+      @run_call_order = next_call_order
+    end
+
+    def public_job
+      job
+    end
+
+    def public_params
+      params
+    end
+
+    def public_logger
+      logger
+    end
+
+    private
+
+    def next_call_order
+      @order ||= 0
+      @order += 1
+    end
+  end
+
+  class FakeRunner
+    attr_accessor :job, :params, :logger
+
+    def initialize
+      @job = Factory.string
+      @params = Factory.string
+      @logger = Factory.string
+    end
+  end
+
+end

data/test/unit/job_tests.rb

@@ -0,0 +1,132 @@
+require 'assert'
+require 'qs/job'
+
+class Qs::Job
+
+  class UnitTests < Assert::Context
+    desc "Qs::Job"
+    setup do
+      @name       = Factory.string
+      @params     = { Factory.string => Factory.string }
+      @created_at = Factory.time
+
+      @job_class = Qs::Job
+    end
+    subject{ @job_class }
+
+    should have_imeths :parse
+
+    should "parse a job from a payload hash" do
+      payload = {
+        'name'       => @name,
+        'params'     => @params,
+        'created_at' => @created_at.to_i
+      }
+      job = subject.parse(payload)
+      assert_instance_of subject, job
+      assert_equal payload['name'], job.name
+      assert_equal payload['params'], job.params
+      assert_equal Time.at(payload['created_at']), job.created_at
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @current_time = Factory.time
+      Assert.stub(Time, :now).with{ @current_time }
+
+      @job = @job_class.new(@name, @params, @created_at)
+    end
+    subject{ @job }
+
+    should have_readers :name, :params, :created_at
+    should have_imeths :to_payload
+
+    should "know its name, params and created at" do
+      assert_equal @name,       subject.name
+      assert_equal @params,     subject.params
+      assert_equal @created_at, subject.created_at
+    end
+
+    should "default its created at" do
+      job = @job_class.new(@name, @params)
+      assert_equal @current_time, job.created_at
+    end
+
+    should "return a payload hash using `to_payload`" do
+      payload_hash = subject.to_payload
+      expected = {
+        'name'       => @name,
+        'params'     => @params,
+        'created_at' => @created_at.to_i
+      }
+      assert_equal expected, payload_hash
+    end
+
+    should "convert job names to strings using `to_payload`" do
+      job = @job_class.new(@name.to_sym, @params)
+      assert_equal @name, job.to_payload['name']
+    end
+
+    should "convert stringify its params using `to_payload`" do
+      params = { Factory.string.to_sym => Factory.string }
+      job = @job_class.new(@name, params)
+      exp = StringifyParams.new(params)
+      assert_equal exp, job.to_payload['params']
+    end
+
+    should "raise an error when given an invalid name or params" do
+      assert_raises(Qs::BadJobError){ @job_class.new(nil, @params) }
+      assert_raises(Qs::BadJobError){ @job_class.new(@name, nil) }
+      assert_raises(Qs::BadJobError){ @job_class.new(@name, Factory.string) }
+    end
+
+    should "have a custom inspect" do
+      reference = '0x0%x' % (subject.object_id << 1)
+      expected = "#<Qs::Job:#{reference} " \
+                 "@name=#{subject.name.inspect} " \
+                 "@params=#{subject.params.inspect} " \
+                 "@created_at=#{subject.created_at.inspect}>"
+      assert_equal expected, subject.inspect
+    end
+
+    should "be comparable" do
+      matching = @job_class.new(@name, @params, @created_at)
+      assert_equal matching, subject
+      non_matching = @job_class.new(Factory.string, @params, @created_at)
+      assert_not_equal non_matching, subject
+      params = { Factory.string => Factory.string }
+      non_matching = @job_class.new(@name, params, @created_at)
+      assert_not_equal non_matching, subject
+      non_matching = @job_class.new(@name, @params, Factory.time)
+      assert_not_equal non_matching, subject
+    end
+
+  end
+
+  class StringifyParamsTests < UnitTests
+    desc "StringifyParams"
+    subject{ StringifyParams }
+
+    should have_imeths :new
+
+    should "convert all hash keys to strings" do
+      key, value = Factory.string.to_sym, Factory.string
+      result = subject.new({
+        key    => value,
+        :hash  => { key => [value] },
+        :array => [{ key => value }]
+      })
+      exp = {
+        key.to_s => value,
+        'hash'   => { key.to_s => [value] },
+        'array'  => [{ key.to_s => value }]
+      }
+      assert_equal exp, result
+    end
+
+  end
+
+end

data/test/unit/logger_tests.rb

@@ -0,0 +1,38 @@
+require 'assert'
+require 'qs/logger'
+
+class Qs::Logger
+
+  class UnitTests < Assert::Context
+    desc "Qs::Logger"
+    setup do
+      @real_logger = Factory.string
+    end
+    subject{ Qs::Logger }
+
+    should "set its loggers correctly in summary mode" do
+      logger = subject.new(@real_logger, false)
+      assert_equal @real_logger, logger.summary
+      assert_instance_of Qs::NullLogger, logger.verbose
+    end
+
+    should "set its loggers correctly in verbose mode" do
+      logger = subject.new(@real_logger, true)
+      assert_instance_of Qs::NullLogger, logger.summary
+      assert_equal @real_logger, logger.verbose
+    end
+
+  end
+
+  class NullLoggerTests < Assert::Context
+    desc "Qs::NullLogger"
+    setup do
+      @null_logger = Qs::NullLogger.new
+    end
+    subject{ @null_logger }
+
+    should have_imeths :debug, :info, :error
+
+  end
+
+end