qs 0.3.0 → 0.4.0

data/test/unit/daemon_data_tests.rb

@@ -59,14 +59,14 @@ class Qs::DaemonData
     end
 
     should "build a routes lookup hash" do
-      expected = @routes.inject({}){ |h, r| h.merge(r.name => r) }
+      expected = @routes.inject({}){ |h, r| h.merge(r.id => r) }
       assert_equal expected, subject.routes
     end
 
     should "allow looking up a route using `route_for`" do
-      expected = @routes.choice
-      route = subject.route_for(expected.name)
-      assert_equal expected, route
+      exp_route = @routes.choice
+      route = subject.route_for(exp_route.id)
+      assert_equal exp_route, route
     end
 
     should "raise a not found error using `route_for` with an invalid name" do

data/test/unit/daemon_tests.rb

@@ -6,7 +6,7 @@ require 'ns-options/assert_macros'
 require 'thread'
 require 'qs/client'
 require 'qs/queue'
-require 'qs/redis_item'
+require 'qs/queue_item'
 
 module Qs::Daemon
 
@@ -275,8 +275,8 @@ module Qs::Daemon
       @daemon = @daemon_class.new
       @thread = @daemon.start
 
-      @serialized_payload = Factory.string
-      @client_spy.append(@queue.redis_key, @serialized_payload)
+      @encoded_payload = Factory.string
+      @client_spy.append(@queue.redis_key, @encoded_payload)
     end
     subject{ @daemon }
 
@@ -285,7 +285,7 @@ module Qs::Daemon
       assert_equal :block_dequeue, call.command
       exp = [subject.signals_redis_key, subject.queue_redis_keys, 0].flatten
       assert_equal exp, call.args
-      exp = Qs::RedisItem.new(@queue.redis_key, @serialized_payload)
+      exp = Qs::QueueItem.new(@queue.redis_key, @encoded_payload)
       assert_equal exp, @worker_pool_spy.work_items.first
     end
 
@@ -353,15 +353,15 @@ module Qs::Daemon
       @daemon = @daemon_class.new
       @thread = @daemon.start
 
-      @redis_item = Qs::RedisItem.new(Factory.string, Factory.string)
-      @worker_pool_spy.work_proc.call(@redis_item)
+      @queue_item = Qs::QueueItem.new(Factory.string, Factory.string)
+      @worker_pool_spy.work_proc.call(@queue_item)
     end
     subject{ @daemon }
 
     should "build and run a payload handler" do
       assert_not_nil @ph_spy
       assert_equal subject.daemon_data, @ph_spy.daemon_data
-      assert_equal @redis_item,         @ph_spy.redis_item
+      assert_equal @queue_item,         @ph_spy.queue_item
     end
 
   end
@@ -373,27 +373,27 @@ module Qs::Daemon
       @thread = @daemon.start
 
       @exception  = Factory.exception
-      @redis_item = Qs::RedisItem.new(Factory.string, Factory.string)
+      @queue_item = Qs::QueueItem.new(Factory.string, Factory.string)
       @callback   = @worker_pool_spy.on_worker_error_callbacks.first
     end
     subject{ @daemon }
 
-    should "requeue the redis item if it wasn't started" do
-      @redis_item.started = false
-      @callback.call('worker', @exception, @redis_item)
+    should "requeue the queue item if it wasn't started" do
+      @queue_item.started = false
+      @callback.call('worker', @exception, @queue_item)
       call = @client_spy.calls.detect{ |c| c.command == :prepend }
       assert_not_nil call
-      assert_equal @redis_item.queue_redis_key,    call.args.first
-      assert_equal @redis_item.serialized_payload, call.args.last
+      assert_equal @queue_item.queue_redis_key, call.args.first
+      assert_equal @queue_item.encoded_payload, call.args.last
     end
 
-    should "not requeue the redis item if it was started" do
-      @redis_item.started = true
-      @callback.call('worker', @exception, @redis_item)
+    should "not requeue the queue item if it was started" do
+      @queue_item.started = true
+      @callback.call('worker', @exception, @queue_item)
       assert_nil @client_spy.calls.detect{ |c| c.command == :prepend }
     end
 
-    should "do nothing if not passed a redis item" do
+    should "do nothing if not passed a queue item" do
       assert_nothing_raised{ @callback.call(@exception, nil) }
     end
 
@@ -402,8 +402,8 @@ module Qs::Daemon
   class StopTests < StartTests
     desc "and then stopped"
     setup do
-      @redis_item = Qs::RedisItem.new(@queue.redis_key, Factory.string)
-      @worker_pool_spy.add_work(@redis_item)
+      @queue_item = Qs::QueueItem.new(@queue.redis_key, Factory.string)
+      @worker_pool_spy.add_work(@queue_item)
 
       @daemon.stop true
     end
@@ -416,8 +416,8 @@ module Qs::Daemon
     should "requeue any work left on the pool" do
       call = @client_spy.calls.last
       assert_equal :prepend, call.command
-      assert_equal @redis_item.queue_redis_key,    call.args.first
-      assert_equal @redis_item.serialized_payload, call.args.last
+      assert_equal @queue_item.queue_redis_key, call.args.first
+      assert_equal @queue_item.encoded_payload, call.args.last
     end
 
     should "stop the work loop thread" do
@@ -449,8 +449,8 @@ module Qs::Daemon
   class HaltTests < StartTests
     desc "and then halted"
     setup do
-      @redis_item = Qs::RedisItem.new(@queue.redis_key, Factory.string)
-      @worker_pool_spy.add_work(@redis_item)
+      @queue_item = Qs::QueueItem.new(@queue.redis_key, Factory.string)
+      @worker_pool_spy.add_work(@queue_item)
 
       @daemon.halt true
     end
@@ -463,8 +463,8 @@ module Qs::Daemon
     should "requeue any work left on the pool" do
       call = @client_spy.calls.last
       assert_equal :prepend, call.command
-      assert_equal @redis_item.queue_redis_key,    call.args.first
-      assert_equal @redis_item.serialized_payload, call.args.last
+      assert_equal @queue_item.queue_redis_key, call.args.first
+      assert_equal @queue_item.encoded_payload, call.args.last
     end
 
     should "stop the work loop thread" do
@@ -501,8 +501,8 @@ module Qs::Daemon
 
       # cause the daemon to loop, its sleeping on the original block_dequeue
       # call that happened before the stub
-      @redis_item = Qs::RedisItem.new(@queue.redis_key, Factory.string)
-      @client_spy.append(@redis_item.queue_redis_key, @redis_item.serialized_payload)
+      @queue_item = Qs::QueueItem.new(@queue.redis_key, Factory.string)
+      @client_spy.append(@queue_item.queue_redis_key, @queue_item.encoded_payload)
     end
 
     should "shutdown the worker pool" do
@@ -513,8 +513,8 @@ module Qs::Daemon
     should "requeue any work left on the pool" do
       call = @client_spy.calls.last
       assert_equal :prepend, call.command
-      assert_equal @redis_item.queue_redis_key,    call.args.first
-      assert_equal @redis_item.serialized_payload, call.args.last
+      assert_equal @queue_item.queue_redis_key, call.args.first
+      assert_equal @queue_item.encoded_payload, call.args.last
     end
 
     should "stop the work loop thread" do
@@ -667,11 +667,11 @@ module Qs::Daemon
   TestHandler = Class.new
 
   class PayloadHandlerSpy
-    attr_reader :daemon_data, :redis_item, :run_called
+    attr_reader :daemon_data, :queue_item, :run_called
 
-    def initialize(daemon_data, redis_item)
+    def initialize(daemon_data, queue_item)
       @daemon_data = daemon_data
-      @redis_item  = redis_item
+      @queue_item  = queue_item
       @run_called  = false
     end
 

data/test/unit/dispatch_job_handler_tests.rb

@@ -0,0 +1,163 @@
+require 'assert'
+require 'qs/dispatch_job_handler'
+
+require 'qs/job_handler_test_helpers'
+
+module Qs::DispatchJobHandler
+
+  class UnitTests < Assert::Context
+    include Qs::JobHandler::TestHelpers
+
+    desc "Qs::DispatchJobHandler"
+    setup do
+      Qs.init
+      @handler_class = Class.new do
+        include Qs::DispatchJobHandler
+      end
+    end
+    teardown do
+      Qs.reset!
+    end
+    subject{ @handler_class }
+
+    should "be a job handler" do
+      assert_includes Qs::JobHandler, subject
+    end
+
+  end
+
+  class InitSetupTests < UnitTests
+    desc "when init"
+    setup do
+      @job = Factory.dispatch_job(:publisher => Factory.string)
+      @queue_names = Factory.integer(3).times.map{ Factory.string }
+      Assert.stub(Qs, :event_subscribers){ @queue_names }
+
+      @push_calls = []
+      Assert.stub(Qs, :push){ |*args| @push_calls << PushCall.new(*args) }
+
+      @logger_spy  = LoggerSpy.new
+      @runner_args = {
+        :job    => @job,
+        :params => @job.params,
+        :logger => @logger_spy
+      }
+    end
+    subject{ @handler }
+
+  end
+
+  class InitTests < InitSetupTests
+    setup do
+      @runner  = test_runner(@handler_class, @runner_args)
+      @handler = @runner.handler
+    end
+
+    should "know its event and subscribed queue names" do
+      assert_equal @job.event,   subject.event
+      assert_equal @queue_names, subject.subscribed_queue_names
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @runner.run
+    end
+
+    should "push the events payload to all of the subscribed queue names" do
+      assert_equal @queue_names, @push_calls.map(&:queue_name)
+      exp = Qs::Payload.event_hash(subject.event)
+      assert_equal [exp], @push_calls.map(&:payload).uniq
+    end
+
+    should "log the queues it dispatches to" do
+      exp = [
+        "Dispatching #{subject.event.route_name}",
+        "  params:       #{subject.event.params.inspect}",
+        "  publisher:    #{subject.event.publisher}",
+        "  published at: #{subject.event.published_at}",
+        "Found #{subject.subscribed_queue_names.size} subscribed queue(s):",
+        @queue_names.map{ |queue_name| "  => #{queue_name}" }
+      ].flatten.join("\n")
+      assert_equal exp, @logger_spy.messages.join("\n")
+    end
+
+  end
+
+  class RunWithDispatchesThatErrorTests < InitSetupTests
+    desc "and run with dispatches that error"
+    setup do
+      @fail_queue_names = Factory.integer(3).times.map{ Factory.string }
+      @dispatch_error = RuntimeError.new(Factory.text)
+      payload_hash = Qs::Payload.event_hash(@job.event)
+      @fail_queue_names.each do |queue_name|
+        Assert.stub(Qs, :push).with(queue_name, payload_hash) do
+          raise @dispatch_error
+        end
+      end
+
+      @success_queue_names = @queue_names.dup
+      # add the fail queue names to the front to test that they don't cause
+      # the other queues not to be dispatched to
+      @queue_names = @fail_queue_names + @success_queue_names
+
+      @runner  = test_runner(@handler_class, @runner_args)
+      @handler = @runner.handler
+
+      @exception = nil
+      begin; @runner.run; rescue => @exception; end
+    end
+
+    should "raise a dispatch error after trying to dispatch to every queue" do
+      assert_equal @success_queue_names, @push_calls.map(&:queue_name)
+
+      assert_instance_of DispatchError, @exception
+      descriptions = @fail_queue_names.map do |queue_name|
+        "#{queue_name} - #{@dispatch_error.class}: #{@dispatch_error.message}"
+      end
+      exp = "#{subject.event.route_name} event wasn't dispatched to:\n" \
+            "  #{descriptions.join("\n  ")}"
+      assert_equal exp, @exception.message
+      exp = @fail_queue_names.map do |queue_name|
+        FailedDispatch.new(queue_name, @dispatch_error)
+      end
+      assert_equal exp, @exception.failed_dispatches
+    end
+
+    should "log the queues it dispatches to and the errors it encounters" do
+      exp = [
+        "Dispatching #{subject.event.route_name}",
+        "  params:       #{subject.event.params.inspect}",
+        "  publisher:    #{subject.event.publisher}",
+        "  published at: #{subject.event.published_at}",
+        "Found #{subject.subscribed_queue_names.size} subscribed queue(s):",
+        @fail_queue_names.map{ |queue_name| "  => #{queue_name} (failed)" },
+        @success_queue_names.map{ |queue_name| "  => #{queue_name}" },
+        "Failed to dispatch the event to #{@fail_queue_names.size} subscribed queues",
+        @fail_queue_names.map do |queue_name|
+          [ queue_name,
+            "  #{@dispatch_error.class}: #{@dispatch_error.message}",
+            "  #{@dispatch_error.backtrace.first}"
+          ]
+        end
+      ].flatten.join("\n")
+      assert_equal exp, @logger_spy.messages.join("\n")
+    end
+
+  end
+
+  PushCall = Struct.new(:queue_name, :payload)
+
+  class LoggerSpy
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+    end
+
+    def info(message); @messages << message; end
+  end
+
+end

data/test/unit/dispatch_job_tests.rb

@@ -0,0 +1,75 @@
+require 'assert'
+require 'qs/dispatch_job'
+
+require 'qs/event'
+require 'qs/job'
+
+class Qs::DispatchJob
+
+  class UnitTests < Assert::Context
+    desc "Qs::DispatchJob"
+    setup do
+      @job_class = Qs::DispatchJob
+    end
+    subject{ @job_class }
+
+    should "be a job" do
+      assert Qs::DispatchJob < Qs::Job
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @event_channel   = Factory.string
+      @event_name      = Factory.string
+      @event_params    = { Factory.string => Factory.string }
+      @event_publisher = Factory.string
+      @created_at      = Factory.time
+      @job = @job_class.new(@event_channel, @event_name, {
+        :event_params    => @event_params,
+        :event_publisher => @event_publisher,
+        :created_at      => @created_at
+      })
+    end
+    teardown do
+      Qs.reset!
+    end
+    subject{ @job }
+
+    should have_imeths :event
+
+    should "know its name, params and created at" do
+      assert_equal Qs.dispatcher_job_name, subject.name
+      exp = {
+        'event_channel'   => @event_channel,
+        'event_name'      => @event_name,
+        'event_params'    => @event_params,
+        'event_publisher' => @event_publisher
+      }
+      assert_equal exp, subject.params
+      assert_equal @created_at, subject.created_at
+    end
+
+    should "default its event params and event publisher" do
+      Qs.config.event_publisher = Factory.string
+      job = @job_class.new(@event_channel, @event_name)
+      assert_equal({}, job.params['event_params'])
+      assert_equal Qs.event_publisher, job.params['event_publisher']
+    end
+
+    should "know how to build an event from its params" do
+      event = subject.event
+      exp = Qs::Event.new(@event_channel, @event_name, {
+        :params       => @event_params,
+        :publisher    => @event_publisher,
+        :published_at => @created_at
+      })
+      assert_equal exp, event
+      assert_same event, subject.event
+    end
+
+  end
+
+end

data/test/unit/dispatcher_queue_tests.rb

@@ -0,0 +1,42 @@
+require 'assert'
+require 'qs/dispatcher_queue'
+
+module Qs::DispatcherQueue
+
+  class UnitTests < Assert::Context
+    desc "Qs::DispatcherQueue"
+    subject{ Qs::DispatcherQueue }
+
+    should have_imeths :new
+
+    should "build a dispatcher queue" do
+      options = {
+        :queue_class            => Class.new(Qs::Queue),
+        :queue_name             => Factory.string,
+        :job_name               => Factory.string,
+        :job_handler_class_name => Factory.string
+      }
+      dispatcher_queue = subject.new(options)
+      assert_instance_of options[:queue_class], dispatcher_queue
+      assert_equal options[:queue_name], dispatcher_queue.name
+
+      route = dispatcher_queue.routes.last
+      assert_instance_of Qs::Route, route
+      exp = Qs::Message::RouteId.new(Qs::Job::PAYLOAD_TYPE, options[:job_name])
+      assert_equal exp, route.id
+      assert_equal options[:job_handler_class_name], route.handler_class_name
+    end
+
+  end
+
+  class RunDispatchJobTests < UnitTests
+    desc "RunDispatchJob"
+    subject{ RunDispatchJob }
+
+    should "be a dispatch job handler" do
+      assert_includes Qs::DispatchJobHandler, subject
+    end
+
+  end
+
+end