qs 0.3.0 → 0.4.0

data/test/unit/error_handler_tests.rb

@@ -13,11 +13,11 @@ class Qs::ErrorHandler
       @daemon_data     = Qs::DaemonData.new
       @queue_redis_key = Qs::Queue::RedisKey.new(Factory.string)
       @context_hash    = {
-        :daemon_data        => @daemon_data,
-        :queue_redis_key    => @queue_redis_key,
-        :serialized_payload => Factory.string,
-        :job                => Factory.string,
-        :handler_class      => Factory.string
+        :daemon_data     => @daemon_data,
+        :queue_redis_key => @queue_redis_key,
+        :encoded_payload => Factory.string,
+        :message         => Factory.string,
+        :handler_class   => Factory.string
       }
 
       @handler_class = Qs::ErrorHandler
@@ -107,15 +107,15 @@ class Qs::ErrorHandler
     subject{ @context }
 
     should have_readers :daemon_data
-    should have_readers :queue_name, :serialized_payload
-    should have_readers :job, :handler_class
+    should have_readers :queue_name, :encoded_payload
+    should have_readers :message, :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[:encoded_payload], subject.encoded_payload
+      assert_equal @context_hash[:message], subject.message
       assert_equal @context_hash[:handler_class], subject.handler_class
     end
 

data/test/unit/event_handler_test_helpers_tests.rb

@@ -0,0 +1,55 @@
+require 'assert'
+require 'qs/event_handler_test_helpers'
+
+require 'qs/event_handler'
+require 'qs/test_runner'
+require 'test/support/runner_spy'
+
+module Qs::EventHandler::TestHelpers
+
+  class UnitTests < Assert::Context
+    desc "Qs::TestHelpers"
+    setup do
+      @test_helpers = Qs::EventHandler::TestHelpers
+    end
+    subject{ @test_helpers }
+
+  end
+
+  class MixinTests < UnitTests
+    desc "as a mixin"
+    setup do
+      @handler_class = Class.new
+      @args = { Factory.string => Factory.string }
+
+      @runner_spy = nil
+      Assert.stub(Qs::EventTestRunner, :new) do |*args|
+        @runner_spy = RunnerSpy.new(*args)
+      end
+
+      context_class = Class.new{ include Qs::EventHandler::TestHelpers }
+      @context = context_class.new
+    end
+    subject{ @context }
+
+    should have_imeths :test_runner, :test_handler
+
+    should "build an event test runner for a given handler using `test_runner`" do
+      result = subject.test_runner(@handler_class, @args)
+
+      assert_not_nil @runner_spy
+      assert_equal @handler_class, @runner_spy.handler_class
+      assert_equal @args, @runner_spy.args
+      assert_equal @runner_spy, result
+    end
+
+    should "return an initialized handler instance using `test_handler`" do
+      result = subject.test_handler(@handler_class, @args)
+
+      assert_not_nil @runner_spy
+      assert_equal @runner_spy.handler, result
+    end
+
+  end
+
+end

data/test/unit/event_handler_tests.rb

@@ -0,0 +1,63 @@
+require 'assert'
+require 'qs/event_handler'
+
+require 'qs/event'
+require 'qs/message_handler'
+
+module Qs::EventHandler
+
+  class UnitTests < Assert::Context
+    desc "Qs::EventHandler"
+    setup do
+      @handler_class = Class.new{ include Qs::EventHandler }
+    end
+    subject{ @handler_class }
+
+    should "be a message handler" do
+      assert_includes Qs::MessageHandler, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @runner  = FakeRunner.new
+      @handler = TestEventHandler.new(@runner)
+    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
+    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
+
+  end
+
+  class TestEventHandler
+    include Qs::EventHandler
+
+    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
+
+  class FakeRunner
+    attr_accessor :message
+
+    def initialize
+      @message = Factory.event
+    end
+  end
+
+end

data/test/unit/event_tests.rb

@@ -0,0 +1,162 @@
+require 'assert'
+require 'qs/event'
+
+require 'qs/message'
+
+class Qs::Event
+
+  class UnitTests < Assert::Context
+    desc "Qs::Event"
+    setup do
+      @channel      = Factory.string
+      @name         = Factory.string
+      @params       = { Factory.string => Factory.string }
+      @publisher    = Factory.string
+      @published_at = Factory.time
+
+      @event_class = Qs::Event
+    end
+    subject{ @event_class }
+
+    should "know its payload type" do
+      assert_equal 'event', PAYLOAD_TYPE
+    end
+
+    should "be a message" do
+      assert subject < Qs::Message
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @current_time = Factory.time
+      Assert.stub(Time, :now).with{ @current_time }
+
+      @event = @event_class.new(@channel, @name, {
+        :params       => @params,
+        :publisher    => @publisher,
+        :published_at => @published_at
+      })
+    end
+    subject{ @event }
+
+    should have_readers :channel, :name, :publisher, :published_at
+    should have_imeths :route_name, :subscribers_redis_key
+
+    should "know its attributes" do
+      assert_equal PAYLOAD_TYPE,  subject.payload_type
+      assert_equal @channel,      subject.channel
+      assert_equal @name,         subject.name
+      assert_equal @params,       subject.params
+      assert_equal @publisher,    subject.publisher
+      assert_equal @published_at, subject.published_at
+    end
+
+    should "default its params and published at to the current time" do
+      event = @event_class.new(@channel, @name)
+      assert_equal({}, event.params)
+      assert_equal @current_time, event.published_at
+    end
+
+    should "know its route name" do
+      exp = RouteName.new(@channel, @name)
+      result = subject.route_name
+      assert_equal exp, result
+      assert_same result, subject.route_name
+    end
+
+    should "know its subscribers redis key" do
+      exp = SubscribersRedisKey.new(subject.route_name)
+      assert_equal exp, subject.subscribers_redis_key
+    end
+
+    should "have a custom inspect" do
+      reference = '0x0%x' % (subject.object_id << 1)
+      exp = "#<Qs::Event:#{reference} " \
+            "@channel=#{subject.channel.inspect} " \
+            "@name=#{subject.name.inspect} " \
+            "@params=#{subject.params.inspect} " \
+            "@publisher=#{subject.publisher.inspect} " \
+            "@published_at=#{subject.published_at.inspect}>"
+      assert_equal exp, subject.inspect
+    end
+
+    should "be comparable" do
+      matching = @event_class.new(@channel, @name, {
+        :params       => @params,
+        :publisher    => @publisher,
+        :published_at => @published_at
+      })
+      assert_equal matching, subject
+
+      non_matching = @event_class.new(Factory.string, @name, {
+        :params       => @params,
+        :publisher    => @publisher,
+        :published_at => @published_at
+      })
+      assert_not_equal non_matching, subject
+      non_matching = @event_class.new(@channel, Factory.string, {
+        :params       => @params,
+        :publisher    => @publisher,
+        :published_at => @published_at
+      })
+      assert_not_equal non_matching, subject
+      non_matching = @event_class.new(@channel, @name, {
+        :params       => { Factory.string => Factory.string },
+        :publisher    => @publisher,
+        :published_at => @published_at
+      })
+      assert_not_equal non_matching, subject
+      non_matching = @event_class.new(@channel, @name, {
+        :params       => @params,
+        :publisher    => Factory.string,
+        :published_at => @published_at
+      })
+      assert_not_equal non_matching, subject
+      non_matching = @event_class.new(@channel, @name, {
+        :params       => @params,
+        :publisher    => @publisher,
+        :published_at => Factory.time
+      })
+      assert_not_equal non_matching, subject
+    end
+
+    should "raise an error when given invalid attributes" do
+      assert_raises(InvalidError){ @event_class.new(nil, @name) }
+      assert_raises(InvalidError){ @event_class.new(@channel, nil) }
+      assert_raises(InvalidError) do
+        @event_class.new(@channel, @name, :params => Factory.string)
+      end
+    end
+
+  end
+
+  class RouteNameTests < UnitTests
+    desc "RouteName"
+    subject{ RouteName }
+
+    should have_imeths :new
+
+    should "return an event route name given an event channel and event name" do
+      assert_equal "#{@channel}:#{@name}", subject.new(@channel, @name)
+    end
+
+  end
+
+  class SubscribersRedisKeyTests < UnitTests
+    desc "SubscribersRedisKey"
+    subject{ SubscribersRedisKey }
+
+    should have_imeths :new
+
+    should "return an event subscribers redis key given an event route name" do
+      event_route_name = RouteName.new(@channel, @name)
+      exp = "events:#{event_route_name}:subscribers"
+      assert_equal exp, subject.new(event_route_name)
+    end
+
+  end
+
+end

data/test/unit/{test_helper_tests.rb → job_handler_test_helper_tests.rb}

@@ -1,15 +1,16 @@
 require 'assert'
-require 'qs/test_helpers'
+require 'qs/job_handler_test_helpers'
 
 require 'qs/job_handler'
+require 'qs/test_runner'
 require 'test/support/runner_spy'
 
-module Qs::TestHelpers
+module Qs::JobHandler::TestHelpers
 
   class UnitTests < Assert::Context
     desc "Qs::TestHelpers"
     setup do
-      @test_helpers = Qs::TestHelpers
+      @test_helpers = Qs::JobHandler::TestHelpers
     end
     subject{ @test_helpers }
 
@@ -17,29 +18,23 @@ module Qs::TestHelpers
 
   class MixinTests < UnitTests
     desc "as a mixin"
-    setup do
-      context_class = Class.new{ include Qs::TestHelpers }
-      @context = context_class.new
-    end
-    subject{ @context }
-
-    should have_imeths :test_runner, :test_handler
-
-  end
-
-  class HandlerTestRunnerTests < MixinTests
-    desc "for handler testing"
     setup do
       @handler_class = Class.new
       @args = { Factory.string => Factory.string }
 
       @runner_spy = nil
-      Assert.stub(Qs::TestRunner, :new) do |*args|
+      Assert.stub(Qs::JobTestRunner, :new) do |*args|
         @runner_spy = RunnerSpy.new(*args)
       end
+
+      context_class = Class.new{ include Qs::JobHandler::TestHelpers }
+      @context = context_class.new
     end
+    subject{ @context }
 
-    should "build a test runner for a given handler" do
+    should have_imeths :test_runner, :test_handler
+
+    should "build a job test runner for a given handler using `test_runner`" do
       result = subject.test_runner(@handler_class, @args)
 
       assert_not_nil @runner_spy
@@ -48,7 +43,7 @@ module Qs::TestHelpers
       assert_equal @runner_spy, result
     end
 
-    should "return an initialized handler instance" do
+    should "return an initialized handler instance using `test_handler`" do
       result = subject.test_handler(@handler_class, @args)
 
       assert_not_nil @runner_spy
@@ -58,4 +53,3 @@ module Qs::TestHelpers
   end
 
 end
-

data/test/unit/job_handler_tests.rb

@@ -1,6 +1,8 @@
 require 'assert'
 require 'qs/job_handler'
 
+require 'qs/message_handler'
+
 module Qs::JobHandler
 
   class UnitTests < Assert::Context
@@ -10,136 +12,8 @@ module 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
+    should "be a message handler" do
+      assert_includes Qs::MessageHandler, subject
     end
 
   end
@@ -147,46 +21,22 @@ module Qs::JobHandler
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner = FakeRunner.new
+      @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
+    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
     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! }
+      exp = "#<#{subject.class}:#{reference} " \
+            "@job=#{@handler.public_job.inspect}>"
+      assert_equal exp, subject.inspect
     end
 
   end
@@ -194,59 +44,16 @@ module Qs::JobHandler
   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
+    def public_job;            job;            end
+    def public_job_name;       job_name;       end
+    def public_job_created_at; job_created_at; end
   end
 
   class FakeRunner
-    attr_accessor :job, :params, :logger
+    attr_accessor :message
 
     def initialize
-      @job = Factory.string
-      @params = Factory.string
-      @logger = Factory.string
+      @message = Factory.job
     end
   end