qs 0.3.0 → 0.4.0

data/test/unit/payload_tests.rb

@@ -0,0 +1,139 @@
+require 'assert'
+require 'qs/payload'
+
+module Qs::Payload
+
+  class UnitTests < Assert::Context
+    desc "Qs::Payload"
+    setup do
+      # the default JSON encoder/decoder is not deterministic, the keys in the
+      # string can be randomly ordered
+      Assert.stub(Qs, :encode){ |hash| hash.to_a.sort }
+      Assert.stub(Qs, :decode){ |array| Hash[array] }
+    end
+    subject{ Qs::Payload }
+
+    should have_imeths :type_method_name
+    should have_imeths :deserialize, :serialize
+    should have_imeths :job, :job_hash
+    should have_imeths :event, :event_hash
+
+    should "convert payload types to method names using `type_method_name`" do
+      assert_equal 'job',   subject.type_method_name(Qs::Job::PAYLOAD_TYPE)
+      assert_equal 'event', subject.type_method_name(Qs::Event::PAYLOAD_TYPE)
+      assert_raises(InvalidError){ subject.type_method_name(Factory.string) }
+    end
+
+    should "serialize and deserialize messages" do
+      message = Factory.message
+      encoded_payload = subject.serialize(message)
+      exp = Qs.encode(subject.send("#{message.payload_type}_hash", message))
+      assert_equal exp, encoded_payload
+      deserialized_job = subject.deserialize(encoded_payload)
+      assert_equal message, deserialized_job
+    end
+
+    should "build jobs and job payload hashes" do
+      job = Factory.job
+      payload_hash = {
+        'type'       => job.payload_type,
+        'name'       => job.name,
+        'params'     => job.params,
+        'created_at' => Timestamp.new(job.created_at)
+      }
+      assert_equal job, subject.job(payload_hash)
+      assert_equal payload_hash, subject.job_hash(job)
+    end
+
+    should "sanitize its jobs attributes when building a job payload hash" do
+      job = Factory.job({
+        :name   => Factory.string.to_sym,
+        :params => { Factory.string.to_sym => Factory.string }
+      })
+      payload_hash = subject.job_hash(job)
+
+      assert_equal job.name.to_s, payload_hash['name']
+      exp = StringifyParams.new(job.params)
+      assert_equal exp, payload_hash['params']
+    end
+
+    should "build events and event payload hashes" do
+      event = Factory.event
+      payload_hash = {
+        'type'         => event.payload_type,
+        'channel'      => event.channel,
+        'name'         => event.name,
+        'params'       => event.params,
+        'publisher'    => event.publisher,
+        'published_at' => Timestamp.new(event.published_at)
+      }
+      assert_equal event, subject.event(payload_hash)
+      assert_equal payload_hash, subject.event_hash(event)
+    end
+
+    should "sanitize its events attributes when building an event payload hash" do
+      event = Factory.event({
+        :channel   => Factory.string.to_sym,
+        :name      => Factory.string.to_sym,
+        :params    => { Factory.string.to_sym => Factory.string },
+        :publisher => Factory.string.to_sym
+      })
+      payload_hash = subject.event_hash(event)
+
+      assert_equal event.channel.to_s, payload_hash['channel']
+      assert_equal event.name.to_s,    payload_hash['name']
+      exp = StringifyParams.new(event.params)
+      assert_equal exp, payload_hash['params']
+      assert_equal event.publisher.to_s, payload_hash['publisher']
+    end
+
+    should "raise errors for unknown parent types" do
+      message = Factory.message
+      Assert.stub(message, :payload_type){ Factory.string }
+      payload_hash = { 'type' => message.payload_type }
+
+      assert_raises(InvalidError){ subject.deserialize(payload_hash) }
+      assert_raises(InvalidError){ subject.serialize(message) }
+    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
+
+  class TimestampTests < UnitTests
+    desc "Timestamp"
+    subject{ Timestamp }
+
+    should have_imeths :to_time, :new
+
+    should "handle building timestamps and converting them to times" do
+      time = Factory.time
+      timestamp = subject.new(time)
+      assert_equal time.to_i, timestamp
+      assert_equal time, subject.to_time(timestamp)
+    end
+
+  end
+
+end

data/test/unit/qs_runner_tests.rb

@@ -2,7 +2,7 @@ require 'assert'
 require 'qs/qs_runner'
 
 require 'qs'
-require 'qs/job_handler'
+require 'qs/message_handler'
 
 class Qs::QsRunner
 
@@ -27,7 +27,7 @@ class Qs::QsRunner
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @handler_class = TestJobHandler
+      @handler_class = TestMessageHandler
       @runner = @runner_class.new(@handler_class)
     end
     subject{ @runner }
@@ -36,8 +36,8 @@ class Qs::QsRunner
     should have_imeths :run
 
     should "know its timeout" do
-      assert_equal TestJobHandler.timeout, subject.timeout
-      handler_class = Class.new{ include Qs::JobHandler }
+      assert_equal TestMessageHandler.timeout, subject.timeout
+      handler_class = Class.new{ include Qs::MessageHandler }
       runner = @runner_class.new(handler_class)
       assert_equal Qs.config.timeout, runner.timeout
     end
@@ -131,8 +131,8 @@ class Qs::QsRunner
 
   end
 
-  class TestJobHandler
-    include Qs::JobHandler
+  class TestMessageHandler
+    include Qs::MessageHandler
 
     attr_reader :first_before_call_order, :second_before_call_order
     attr_reader :first_after_call_order, :second_after_call_order

data/test/unit/qs_tests.rb

@@ -3,7 +3,6 @@ require 'qs'
 
 require 'hella-redis/connection_spy'
 require 'ns-options/assert_macros'
-require 'qs/job'
 require 'qs/queue'
 
 module Qs
@@ -21,9 +20,14 @@ module Qs
     subject{ @module }
 
     should have_imeths :config, :configure, :init, :reset!
-    should have_imeths :enqueue, :push
-    should have_imeths :serialize, :deserialize
+    should have_imeths :enqueue, :publish, :publish_as, :push
+    should have_imeths :encode, :decode
+    should have_imeths :sync_subscriptions, :clear_subscriptions
+    should have_imeths :event_subscribers
     should have_imeths :client, :redis, :redis_config
+    should have_imeths :dispatcher_queue, :dispatcher_job_name
+    should have_imeths :event_publisher
+    should have_imeths :published_events
 
     should "know its config" do
       assert_instance_of Config, subject.config
@@ -32,7 +36,7 @@ module Qs
     should "allow configuring its config" do
       yielded = nil
       subject.configure{ |c| yielded = c }
-      assert_equal subject.config, yielded
+      assert_same subject.config, yielded
     end
 
     should "not have a client or redis connection by default" do
@@ -50,11 +54,16 @@ module Qs
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @module.config.serializer   = proc{ |v| v.to_s }
-      @module.config.deserializer = proc{ |v| v.to_i }
-      @module.config.redis.ip     = Factory.string
-      @module.config.redis.port   = Factory.integer
-      @module.config.redis.db     = Factory.integer
+      @module.config.encoder    = proc{ |v| v.to_s }
+      @module.config.decoder    = proc{ |v| v.to_i }
+      @module.config.redis.ip   = Factory.string
+      @module.config.redis.port = Factory.integer
+      @module.config.redis.db   = Factory.integer
+
+      @dispatcher_queue_spy = nil
+      Assert.stub(DispatcherQueue, :new) do |*args|
+        @dispatcher_queue_spy = DispatcherQueueSpy.new(*args)
+      end
 
       @client_spy = nil
       Assert.stub(Client, :new) do |*args|
@@ -73,6 +82,17 @@ module Qs
       assert_equal expected, subject.config.redis.url
     end
 
+    should "build a dispatcher queue" do
+      assert_equal @dispatcher_queue_spy, subject.dispatcher_queue
+      exp = subject.config.dispatcher_queue_class
+      assert_equal exp, @dispatcher_queue_spy.queue_class
+      dispatcher_config = subject.config.dispatcher
+      assert_equal dispatcher_config.queue_name, @dispatcher_queue_spy.queue_name
+      assert_equal dispatcher_config.job_name,   @dispatcher_queue_spy.job_name
+      exp = dispatcher_config.job_handler_class_name
+      assert_equal exp, @dispatcher_queue_spy.job_handler_class_name
+    end
+
     should "build a client" do
       assert_equal @client_spy,          subject.client
       assert_equal @client_spy.redis,    subject.redis
@@ -91,6 +111,32 @@ module Qs
       assert_equal job_params, call.job_params
     end
 
+    should "call publish on its client using `publish`" do
+      event_channel = Factory.string
+      event_name    = Factory.string
+      event_params  = { Factory.string => Factory.string }
+      subject.publish(event_channel, event_name, event_params)
+
+      call = @client_spy.publish_calls.last
+      assert_equal event_channel, call.event_channel
+      assert_equal event_name,    call.event_name
+      assert_equal event_params,  call.event_params
+    end
+
+    should "call publish as on its client using `publish_as`" do
+      event_publisher = Factory.string
+      event_channel   = Factory.string
+      event_name      = Factory.string
+      event_params    = { Factory.string => Factory.string }
+      subject.publish_as(event_publisher, event_channel, event_name, event_params)
+
+      call = @client_spy.publish_calls.last
+      assert_equal event_publisher, call.event_publisher
+      assert_equal event_channel,   call.event_channel
+      assert_equal event_name,      call.event_name
+      assert_equal event_params,    call.event_params
+    end
+
     should "call push on its client using `push`" do
       queue_name = Factory.string
       payload    = { Factory.string => Factory.string }
@@ -101,22 +147,58 @@ module Qs
       assert_equal payload,    call.payload
     end
 
-    should "use the configured serializer using `serialize`" do
+    should "use the configured encoder using `encode`" do
       value = Factory.integer
-      result = subject.serialize(value)
+      result = subject.encode(value)
       assert_equal value.to_s, result
     end
 
-    should "use the configured deserializer using `deserialize`" do
+    should "use the configured decoder using `decode`" do
       value = Factory.integer.to_s
-      result = subject.deserialize(value)
+      result = subject.decode(value)
       assert_equal value.to_i, result
     end
 
-    should "not reset its client or redis connection when init again" do
+    should "demeter its clients subscription methods" do
+      queue = Qs::Queue.new{ name Factory.string }
+
+      subject.sync_subscriptions(queue)
+      call = @client_spy.sync_subscriptions_calls.last
+      assert_equal queue, call.queue
+
+      subject.clear_subscriptions(queue)
+      call = @client_spy.clear_subscriptions_calls.last
+      assert_equal queue, call.queue
+    end
+
+    should "demeter its event publishers method to its client" do
+      event = Factory.event
+      subject.event_subscribers(event)
+
+      call = @client_spy.event_subscribers_calls.last
+      assert_equal event, call.event
+    end
+
+    should "know its dispatcher job name and event publisher" do
+      exp = subject.config.dispatcher.job_name
+      assert_equal exp, subject.dispatcher_job_name
+      exp = subject.config.event_publisher
+      assert_equal exp, subject.event_publisher
+    end
+
+    should "return the dispatcher queue published events using `published_events`" do
+      queue = subject.dispatcher_queue
+      published_events = Factory.integer(3).times.map{ Factory.string }
+      Assert.stub(queue, :published_events){ published_events }
+      assert_equal queue.published_events, subject.published_events
+    end
+
+    should "not reset its attributes when init again" do
+      queue  = subject.dispatcher_queue
       client = subject.client
       redis  = subject.redis
       subject.init
+      assert_same queue,  subject.dispatcher_queue
       assert_same client, subject.client
       assert_same redis,  subject.redis
     end
@@ -124,10 +206,11 @@ module Qs
     should "reset itself using `reset!`" do
       subject.reset!
       assert_nil subject.config.redis.url
+      assert_nil subject.dispatcher_queue
       assert_nil subject.client
       assert_nil subject.redis
-      assert_raises(NoMethodError){ subject.serialize(Factory.integer) }
-      assert_raises(NoMethodError){ subject.deserialize(Factory.integer) }
+      assert_raises(NoMethodError){ subject.encode(Factory.integer) }
+      assert_raises(NoMethodError){ subject.decode(Factory.integer) }
     end
 
   end
@@ -141,25 +224,39 @@ module Qs
     end
     subject{ @config }
 
-    should have_options :serializer, :deserializer, :timeout
-    should have_namespace :redis
+    should have_options :encoder, :decoder, :timeout
+    should have_options :event_publisher
+    should have_namespace :dispatcher, :redis
+    should have_accessors :dispatcher_queue_class
 
-    should "know its default serializer/deserializer" do
+    should "know its default decoder/encoder" do
       payload = { Factory.string => Factory.string }
 
       exp = JSON.dump(payload)
-      serialized_payload = subject.serializer.call(payload)
-      assert_equal exp, serialized_payload
+      encoded_payload = subject.encoder.call(payload)
+      assert_equal exp, encoded_payload
       exp = JSON.load(exp)
-      assert_equal exp, subject.deserializer.call(serialized_payload)
+      assert_equal exp, subject.decoder.call(encoded_payload)
     end
 
     should "know its default timeout" do
       assert_nil subject.timeout
     end
 
+    should "not have a default event publisher" do
+      assert_nil subject.event_publisher
+    end
+
+    should "know its default dispatcher options" do
+      assert_equal Queue, subject.dispatcher_queue_class
+      assert_equal 'dispatcher', subject.dispatcher.queue_name
+      assert_equal 'run_dispatch_job', subject.dispatcher.job_name
+      exp = DispatcherQueue::RunDispatchJob.to_s
+      assert_equal exp, subject.dispatcher.job_handler_class_name
+    end
+
     should "know its default redis options" do
-      assert_equal 'localhost', subject.redis.ip
+      assert_equal '127.0.0.1', subject.redis.ip
       assert_equal 6379,        subject.redis.port
       assert_equal 0,           subject.redis.db
       assert_equal 'qs',        subject.redis.redis_ns
@@ -191,27 +288,69 @@ module Qs
 
   end
 
+  class DispatcherQueueSpy
+    attr_reader :queue_class, :queue_name
+    attr_reader :job_name, :job_handler_class_name
+    attr_reader :published_events
+
+    def initialize(options)
+      @queue_class            = options[:queue_class]
+      @queue_name             = options[:queue_name]
+      @job_name               = options[:job_name]
+      @job_handler_class_name = options[:job_handler_class_name]
+    end
+  end
+
   class ClientSpy
     attr_reader :redis_config, :redis
-    attr_reader :enqueue_calls, :push_calls
+    attr_reader :enqueue_calls, :publish_calls, :push_calls
+    attr_reader :sync_subscriptions_calls, :clear_subscriptions_calls
+    attr_reader :event_subscribers_calls
 
     def initialize(redis_confg)
       @redis_config  = redis_confg
       @redis         = Factory.string
       @enqueue_calls = []
+      @publish_calls = []
       @push_calls    = []
+      @sync_subscriptions_calls  = []
+      @clear_subscriptions_calls = []
+      @event_subscribers_calls   = []
+    end
+
+    def enqueue(queue, name, params = nil)
+      @enqueue_calls << EnqueueCall.new(queue, name, params)
+    end
+
+    def publish(channel, name, params = nil)
+      @publish_calls << PublishCall.new(channel, name, params)
     end
 
-    def enqueue(queue, job_name, job_params = nil)
-      @enqueue_calls << EnqueueCall.new(queue, job_name, job_params)
+    def publish_as(publisher, channel, name, params = nil)
+      @publish_calls << PublishCall.new(channel, name, params, publisher)
     end
 
     def push(queue_name, payload)
       @push_calls << PushCall.new(queue_name, payload)
     end
 
-    EnqueueCall = Struct.new(:queue, :job_name, :job_params)
-    PushCall    = Struct.new(:queue_name, :payload)
+    def sync_subscriptions(queue)
+      @sync_subscriptions_calls << SubscriptionsCall.new(queue)
+    end
+
+    def clear_subscriptions(queue)
+      @clear_subscriptions_calls << SubscriptionsCall.new(queue)
+    end
+
+    def event_subscribers(event)
+      @event_subscribers_calls << SubscribersCall.new(event)
+    end
+
+    EnqueueCall       = Struct.new(:queue, :job_name, :job_params)
+    PublishCall       = Struct.new(:event_channel, :event_name, :event_params, :event_publisher)
+    PushCall          = Struct.new(:queue_name, :payload)
+    SubscriptionsCall = Struct.new(:queue, :event_job_names)
+    SubscribersCall   = Struct.new(:event)
   end
 
 end