qs 0.3.0 → 0.4.0

data/test/unit/queue_item_tests.rb

@@ -0,0 +1,51 @@
+require 'assert'
+require 'qs/queue_item'
+
+require 'qs/queue'
+
+class Qs::QueueItem
+
+  class UnitTests < Assert::Context
+    desc "Qs::QueueItem"
+    setup do
+      @queue_redis_key = Factory.string
+      @encoded_payload = Factory.string
+      @queue_item = Qs::QueueItem.new(@queue_redis_key, @encoded_payload)
+    end
+    subject{ @queue_item }
+
+    should have_readers :queue_redis_key, :encoded_payload
+    should have_accessors :started, :finished
+    should have_accessors :message, :handler_class
+    should have_accessors :exception, :time_taken
+
+    should "know its queue redis key and encoded payload" do
+      assert_equal @queue_redis_key, subject.queue_redis_key
+      assert_equal @encoded_payload, subject.encoded_payload
+    end
+
+    should "defaults its other attributes" do
+      assert_false subject.started
+      assert_false subject.finished
+
+      assert_nil subject.message
+      assert_nil subject.handler_class
+      assert_nil subject.exception
+      assert_nil subject.time_taken
+    end
+
+    should "know if it equals another item" do
+      exp = Qs::QueueItem.new(@queue_redis_key, @encoded_payload)
+      assert_equal exp, subject
+
+      redis_key = Qs::Queue::RedisKey.new(Factory.string)
+      exp = Qs::QueueItem.new(redis_key, @encoded_payload)
+      assert_not_equal exp, subject
+
+      exp = Qs::QueueItem.new(@queue_redis_key, Factory.string)
+      assert_not_equal exp, subject
+    end
+
+  end
+
+end

data/test/unit/queue_tests.rb

@@ -8,22 +8,21 @@ class Qs::Queue
   class UnitTests < Assert::Context
     desc "Qs::Queue"
     setup do
-      @queue = Qs::Queue.new do
-        name Factory.string
-      end
+      @queue = Qs::Queue.new{ name Factory.string }
     end
     subject{ @queue }
 
-    should have_readers :routes, :enqueued_jobs
-    should have_imeths :name, :redis_key, :job_handler_ns, :job
+    should have_readers :routes, :event_route_names, :enqueued_jobs
+    should have_imeths :name, :redis_key
+    should have_imeths :job_handler_ns, :job
+    should have_imeths :event_handler_ns, :event
     should have_imeths :enqueue, :add
-    should have_imeths :reset!
+    should have_imeths :sync_subscriptions, :clear_subscriptions
+    should have_imeths :published_events, :reset!
 
-    should "default its routes to an empty array" do
+    should "default its routes, event route names and enqueued jobs" do
       assert_equal [], subject.routes
-    end
-
-    should "default its enqueued jobs to an empty array" do
+      assert_equal [], subject.event_route_names
       assert_equal [], subject.enqueued_jobs
     end
 
@@ -49,35 +48,124 @@ class Qs::Queue
       assert_equal namespace, subject.job_handler_ns
     end
 
-    should "allow adding routes using `job`" do
-      job_name = Factory.string
+    should "not have an event handler ns by default" do
+      assert_nil subject.event_handler_ns
+    end
+
+    should "allow setting its event handler ns" do
+      namespace = Factory.string
+      subject.event_handler_ns namespace
+      assert_equal namespace, subject.event_handler_ns
+    end
+
+    should "allow adding job routes using `job`" do
+      job_name     = Factory.string
       handler_name = Factory.string
       subject.job job_name, handler_name
 
       route = subject.routes.last
       assert_instance_of Qs::Route, route
-      assert_equal job_name, route.name
+      exp = Qs::Message::RouteId.new(Qs::Job::PAYLOAD_TYPE, job_name)
+      assert_equal exp, route.id
       assert_equal handler_name, route.handler_class_name
     end
 
-    should "use its job handler ns when adding routes" do
+    should "use its job handler ns when adding job routes" do
       namespace = Factory.string
       subject.job_handler_ns namespace
 
-      job_name = Factory.string
+      job_name     = Factory.string
       handler_name = Factory.string
       subject.job job_name, handler_name
 
       route = subject.routes.last
-      expected = "#{namespace}::#{handler_name}"
-      assert_equal expected, route.handler_class_name
+      exp = "#{namespace}::#{handler_name}"
+      assert_equal exp, route.handler_class_name
+    end
+
+    should "not use its job handler ns with a top-level handler name" do
+      namespace = Factory.string
+      subject.job_handler_ns namespace
+
+      job_name     = Factory.string
+      handler_name = "::#{Factory.string}"
+      subject.job job_name, handler_name
+
+      route = subject.routes.last
+      assert_equal handler_name, route.handler_class_name
+    end
+
+    should "allow adding event routes using `event`" do
+      event_channel = Factory.string
+      event_name    = Factory.string
+      handler_name  = Factory.string
+      subject.event event_channel, event_name, handler_name
+
+      route = subject.routes.last
+      assert_instance_of Qs::Route, route
+      route_name = Qs::Event::RouteName.new(event_channel, event_name)
+      exp = Qs::Message::RouteId.new(Qs::Event::PAYLOAD_TYPE, route_name)
+      assert_equal exp, route.id
+      assert_equal handler_name, route.handler_class_name
+    end
+
+    should "use its event handler ns when adding event routes" do
+      namespace = Factory.string
+      subject.event_handler_ns namespace
+
+      event_channel = Factory.string
+      event_name    = Factory.string
+      handler_name  = Factory.string
+      subject.event event_channel, event_name, handler_name
+
+      route = subject.routes.last
+      exp = "#{namespace}::#{handler_name}"
+      assert_equal exp, route.handler_class_name
+    end
+
+    should "not use its event handler ns with a top-level handler name" do
+      namespace = Factory.string
+      subject.event_handler_ns namespace
+
+      event_channel = Factory.string
+      event_name    = Factory.string
+      handler_name  = "::#{Factory.string}"
+      subject.event event_channel, event_name, handler_name
+
+      route = subject.routes.last
+      assert_equal handler_name, route.handler_class_name
+    end
+
+    should "track its configured event route names" do
+      event_channel = Factory.string
+      event_name    = Factory.string
+      handler_name  = Factory.string
+      subject.event event_channel, event_name, handler_name
+
+      exp = Qs::Event::RouteName.new(event_channel, event_name)
+      assert_equal [exp], subject.event_route_names
+    end
+
+    should "return the enqueued jobs events using `published_events`" do
+      dispatch_jobs = Factory.integer(3).times.map do
+        Factory.dispatch_job.tap{ |j| subject.enqueued_jobs << j }
+      end
+      assert_equal dispatch_jobs.map(&:event), subject.published_events
+    end
+
+    should "clear its enqueued jobs when reset" do
+      Factory.integer(3).times.map{ subject.enqueued_jobs << Factory.job }
+      assert_not_empty subject.enqueued_jobs
+      subject.reset!
+      assert_empty subject.enqueued_jobs
     end
 
     should "know its custom inspect" do
       reference = '0x0%x' % (subject.object_id << 1)
       expected = "#<#{subject.class}:#{reference} " \
                    "@name=#{subject.name.inspect} " \
-                   "@job_handler_ns=#{subject.job_handler_ns.inspect}>"
+                   "@job_handler_ns=#{subject.job_handler_ns.inspect} " \
+                   "@event_handler_ns=#{subject.event_handler_ns.inspect}>"
       assert_equal expected, subject.inspect
     end
 
@@ -112,6 +200,26 @@ class Qs::Queue
 
   end
 
+  class SubscriptionsTests < UnitTests
+    setup do
+      @sync_args = nil
+      Assert.stub(Qs, :sync_subscriptions){ |*args| @sync_args = args }
+      @clear_args = nil
+      Assert.stub(Qs, :clear_subscriptions){ |*args| @clear_args = args }
+    end
+
+    should "use Qs to sync its subscriptions" do
+      subject.sync_subscriptions
+      assert_equal [subject], @sync_args
+    end
+
+    should "use Qs to clear its subscriptions" do
+      subject.clear_subscriptions
+      assert_equal [subject], @clear_args
+    end
+
+  end
+
   class RedisKeyTests < UnitTests
     desc "RedisKey"
     subject{ RedisKey }

data/test/unit/route_tests.rb

@@ -3,7 +3,6 @@ require 'qs/route'
 
 require 'qs/daemon_data'
 require 'qs/logger'
-require 'qs/job'
 require 'test/support/runner_spy'
 
 class Qs::Route
@@ -11,17 +10,17 @@ class Qs::Route
   class UnitTests < Assert::Context
     desc "Qs::Route"
     setup do
-      @name = Factory.string
+      @id = Factory.string
       @handler_class_name = TestHandler.to_s
-      @route = Qs::Route.new(@name, @handler_class_name)
+      @route = Qs::Route.new(@id, @handler_class_name)
     end
     subject{ @route }
 
-    should have_readers :name, :handler_class_name, :handler_class
+    should have_readers :id, :handler_class_name, :handler_class
     should have_imeths :validate!, :run
 
-    should "know its name and handler class name" do
-      assert_equal @name, subject.name
+    should "know its id and handler class name" do
+      assert_equal @id, subject.id
       assert_equal @handler_class_name, subject.handler_class_name
     end
 
@@ -39,7 +38,7 @@ class Qs::Route
   class RunTests < UnitTests
     desc "when run"
     setup do
-      @job = Qs::Job.new(Factory.string, Factory.string => Factory.string)
+      @message = Factory.message
       @daemon_data = Qs::DaemonData.new(:logger => Qs::NullLogger.new)
 
       @runner_spy = nil
@@ -47,18 +46,18 @@ class Qs::Route
         @runner_spy = RunnerSpy.new(*args)
       end
 
-      @route.run(@job, @daemon_data)
+      @route.run(@message, @daemon_data)
     end
 
     should "build and run a qs runner" do
       assert_not_nil @runner_spy
       assert_equal @route.handler_class, @runner_spy.handler_class
-      expected = {
-        :job    => @job,
-        :params => @job.params,
-        :logger => @daemon_data.logger
+      exp = {
+        :message => @message,
+        :params  => @message.params,
+        :logger  => @daemon_data.logger
       }
-      assert_equal expected, @runner_spy.args
+      assert_equal exp, @runner_spy.args
       assert_true @runner_spy.run_called
     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 :job, :params, :logger
+    should have_readers :message, :params, :logger
     should have_imeths :run
 
     should "know its handler class and handler" do
@@ -32,22 +32,22 @@ class Qs::Runner
       assert_instance_of @handler_class, subject.handler
     end
 
-    should "not set its job, params or logger by default" do
-      assert_nil subject.job
+    should "not set its message, params or logger by default" do
+      assert_nil subject.message
       assert_equal({}, subject.params)
       assert_instance_of Qs::NullLogger, subject.logger
     end
 
-    should "allow passing a job, params and logger" do
+    should "allow passing a message, params and logger" do
       args = {
-        :job    => Factory.string,
-        :params => Factory.string,
-        :logger => Factory.string
+        :message => Factory.string,
+        :params  => Factory.string,
+        :logger  => Factory.string
       }
       runner = @runner_class.new(@handler_class, args)
-      assert_equal args[:job],    runner.job
-      assert_equal args[:params], runner.params
-      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

data/test/unit/test_runner_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 require 'qs/test_runner'
 
 require 'qs'
+require 'qs/event'
 
 class Qs::TestRunner
 
@@ -25,28 +26,28 @@ class Qs::TestRunner
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @handler_class = TestJobHandler
+      @handler_class = TestMessageHandler
       @args = {
-        :job    => Factory.string,
-        :params => { Factory.string => Factory.string },
-        :logger => Factory.string,
-        :flag   => Factory.boolean
+        :message => Factory.message,
+        :params  => { Factory.string => Factory.string },
+        :logger  => Factory.string,
+        :flag    => Factory.boolean
       }
       @original_args = @args.dup
-      @runner = @runner_class.new(@handler_class, @args)
+      @runner  = @runner_class.new(@handler_class, @args)
       @handler = @runner.handler
     end
     subject{ @runner }
 
     should have_imeths :run
 
-    should "know its job, params and logger" do
-      assert_equal @args[:job], subject.job
-      assert_equal @args[:params], subject.params
-      assert_equal @args[:logger], subject.logger
+    should "know its message, params and logger" do
+      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 job handler" do
+    should "write extra args to its message handler" do
       assert_equal @args[:flag], @handler.flag
     end
 
@@ -54,23 +55,23 @@ class Qs::TestRunner
       assert_equal @original_args, @args
     end
 
-    should "not call its job handler's before callbacks" do
+    should "not call its message handler's before callbacks" do
       assert_nil @handler.before_called
     end
 
-    should "call its job handler's init" do
+    should "call its message handler's init" do
       assert_true @handler.init_called
     end
 
-    should "not run its job handler" do
+    should "not run its message handler" do
       assert_nil @handler.run_called
     end
 
-    should "not call its job handler's after callbacks" do
+    should "not call its message handler's after callbacks" do
       assert_nil @handler.after_called
     end
 
-    should "stringify and serialize the params passed to it" do
+    should "stringify and encode the params passed to it" do
       key, value = Factory.string.to_sym, Factory.string
       params = {
         key    => value,
@@ -84,10 +85,6 @@ class Qs::TestRunner
       assert_equal exp, runner.params
     end
 
-    should "raise an invalid error when not passed a job handler" do
-      assert_raises(Qs::InvalidJobHandlerError){ @runner_class.new(Class.new) }
-    end
-
   end
 
   class RunTests < InitTests
@@ -96,18 +93,104 @@ class Qs::TestRunner
       @runner.run
     end
 
-    should "run its job handler" do
+    should "run its message handler" do
       assert_true @handler.run_called
     end
 
-    should "not call its job handler's after callbacks" do
+    should "not call its message handler's after callbacks" do
       assert_nil @handler.after_called
     end
 
   end
 
-  class TestJobHandler
-    include Qs::JobHandler
+  class JobTestRunnerTests < UnitTests
+    desc "JobTestRunner"
+    setup do
+      @runner_class = Qs::JobTestRunner
+    end
+    subject{ @runner_class }
+
+    should "be a test runner" do
+      assert_true subject < Qs::TestRunner
+    end
+
+  end
+
+  class JobTestRunnerInitTests < JobTestRunnerTests
+    desc "when init"
+    setup do
+      @handler_class = TestJobHandler
+      @args = { :job => Factory.job }
+      @original_args = @args.dup
+      @runner = @runner_class.new(@handler_class, @args)
+    end
+    subject{ @runner }
+
+    should "allow passing a job as its message" do
+      assert_equal @args[:job], subject.message
+    end
+
+    should "use job over message if both are provided" do
+      @args[:message] = Factory.message
+      runner = @runner_class.new(@handler_class, @args)
+      assert_equal @args[:job], runner.message
+    end
+
+    should "not alter the args passed to it" do
+      assert_equal @original_args, @args
+    end
+
+    should "raise an invalid error when not passed a job handler" do
+      assert_raises(Qs::InvalidJobHandlerError){ @runner_class.new(Class.new) }
+    end
+
+  end
+
+  class EventTestRunnerTests < UnitTests
+    desc "EventTestRunner"
+    setup do
+      @runner_class = Qs::EventTestRunner
+    end
+    subject{ @runner_class }
+
+    should "be a test runner" do
+      assert_true subject < Qs::TestRunner
+    end
+
+  end
+
+  class EventTestRunnerInitTests < EventTestRunnerTests
+    desc "when init"
+    setup do
+      @handler_class = TestEventHandler
+      @args = { :event => Factory.event }
+      @original_args = @args.dup
+      @runner = @runner_class.new(@handler_class, @args)
+    end
+    subject{ @runner }
+
+    should "allow passing an event as its message" do
+      assert_equal @args[:event], subject.message
+    end
+
+    should "use event over message if both are provided" do
+      @args[:message] = Factory.message
+      runner = @runner_class.new(@handler_class, @args)
+      assert_equal @args[:event], runner.message
+    end
+
+    should "not alter the args passed to it" do
+      assert_equal @original_args, @args
+    end
+
+    should "raise an invalid error when not passed an event handler" do
+      assert_raises(Qs::InvalidEventHandlerError){ @runner_class.new(Class.new) }
+    end
+
+  end
+
+  class TestMessageHandler
+    include Qs::MessageHandler
 
     attr_reader :before_called, :after_called
     attr_reader :init_called, :run_called
@@ -125,4 +208,14 @@ class Qs::TestRunner
     end
   end
 
+  class TestJobHandler
+    include Qs::JobHandler
+
+  end
+
+  class TestEventHandler
+    include Qs::EventHandler
+
+  end
+
 end