qs 0.3.0 → 0.4.0

data/test/system/daemon_tests.rb

@@ -11,26 +11,39 @@ module Qs::Daemon
       Qs.reset!
       @qs_test_mode = ENV['QS_TEST_MODE']
       ENV['QS_TEST_MODE'] = nil
+      Qs.config.dispatcher.queue_name = 'qs-app-dispatcher'
+      Qs.config.event_publisher       = 'Daemon System Tests'
       Qs.init
+      AppQueue.sync_subscriptions
       @orig_config = AppDaemon.configuration.to_hash
     end
     teardown do
       @daemon_runner.stop if @daemon_runner
       AppDaemon.configuration.apply(@orig_config) # reset daemon config
-      Qs.redis.with{ |c| c.del('slow') }
-      Qs.redis.with{ |c| c.del('last_error') }
+      Qs.redis.with do |c|
+        keys = c.keys('*qs-app*')
+        c.pipelined{ keys.each{ |k| c.del(k) } }
+      end
       Qs.client.clear(AppQueue.redis_key)
+      AppQueue.clear_subscriptions
       Qs.reset!
       ENV['QS_TEST_MODE'] = @qs_test_mode
     end
 
+    private
+
+    def setup_app_and_dispatcher_daemon
+      @app_daemon        = AppDaemon.new
+      @dispatcher_daemon = DispatcherDaemon.new
+      @daemon_runner     = DaemonRunner.new(@app_daemon, @dispatcher_daemon)
+      @app_thread        = @daemon_runner.start
+    end
+
   end
 
   class RunningDaemonSetupTests < SystemTests
     setup do
-      @daemon = AppDaemon.new
-      @daemon_runner = DaemonRunner.new(@daemon)
-      @thread = @daemon_runner.start
+      setup_app_and_dispatcher_daemon
     end
 
   end
@@ -43,11 +56,11 @@ module Qs::Daemon
         'key'   => @key,
         'value' => @value
       })
-      @thread.join 0.5
+      @app_thread.join 0.5
     end
 
     should "run the job" do
-      assert_equal @value, Qs.redis.with{ |c| c.get(@key) }
+      assert_equal @value, Qs.redis.with{ |c| c.get("qs-app:#{@key}") }
     end
 
   end
@@ -57,12 +70,12 @@ module Qs::Daemon
     setup do
       @error_message = Factory.text
       AppQueue.add('error', 'error_message' => @error_message)
-      @thread.join 0.5
+      @app_thread.join 0.5
     end
 
     should "run the configured error handler procs" do
       exp = "RuntimeError: #{@error_message}"
-      assert_equal exp, Qs.redis.with{ |c| c.get('last_error') }
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
     end
 
   end
@@ -71,14 +84,62 @@ module Qs::Daemon
     desc "with a job that times out"
     setup do
       AppQueue.add('timeout')
-      @thread.join 1 # let the daemon have time to process the job
+      @app_thread.join 1 # let the daemon have time to process the job
     end
 
     should "run the configured error handler procs" do
       handler_class = AppHandlers::Timeout
       exp = "Qs::TimeoutError: #{handler_class} timed out " \
             "(#{handler_class.timeout}s)"
-      assert_equal exp, Qs.redis.with{ |c| c.get('last_error') }
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
+    end
+
+  end
+
+  class BasicEventTests < RunningDaemonSetupTests
+    desc "with a basic event added"
+    setup do
+      @key, @value = [Factory.string, Factory.string]
+      Qs.publish('qs-app', 'basic', {
+        'key'   => @key,
+        'value' => @value
+      })
+      @app_thread.join 0.5
+    end
+
+    should "run the event" do
+      assert_equal @value, Qs.redis.with{ |c| c.get("qs-app:#{@key}") }
+    end
+
+  end
+
+  class EventThatErrorsTests < RunningDaemonSetupTests
+    desc "with an event that errors"
+    setup do
+      @error_message = Factory.text
+      Qs.publish('qs-app', 'error', 'error_message' => @error_message)
+      @app_thread.join 0.5
+    end
+
+    should "run the configured error handler procs" do
+      exp = "RuntimeError: #{@error_message}"
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
+    end
+
+  end
+
+  class TimeoutEventTests < RunningDaemonSetupTests
+    desc "with an event that times out"
+    setup do
+      Qs.publish('qs-app', 'timeout')
+      @app_thread.join 1 # let the daemon have time to process the job
+    end
+
+    should "run the configured error handler procs" do
+      handler_class = AppHandlers::TimeoutEvent
+      exp = "Qs::TimeoutError: #{handler_class} timed out " \
+            "(#{handler_class.timeout}s)"
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
 
   end
@@ -87,21 +148,19 @@ module Qs::Daemon
     desc "when no workers are available"
     setup do
       AppDaemon.workers 0 # no workers available, don't do this
-      @daemon = AppDaemon.new
-      @daemon_runner = DaemonRunner.new(@daemon)
-      @thread = @daemon_runner.start
+      setup_app_and_dispatcher_daemon
     end
 
     should "shutdown when stopped" do
-      @daemon.stop
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
+      @app_daemon.stop
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
     end
 
     should "shutdown when halted" do
-      @daemon.halt
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
+      @app_daemon.halt
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
     end
 
   end
@@ -110,28 +169,31 @@ module Qs::Daemon
     desc "without a shutdown timeout"
     setup do
       AppDaemon.shutdown_timeout nil # disable shutdown timeout
-      @daemon = AppDaemon.new
-      @daemon_runner = DaemonRunner.new(@daemon)
-      @thread = @daemon_runner.start
+      setup_app_and_dispatcher_daemon
 
       AppQueue.add('slow')
-      @thread.join 1 # let the daemon have time to process the job
+      Qs.publish('qs-app', 'slow')
+      @app_thread.join 1 # let the daemon have time to process the job and event
     end
 
-    should "shutdown and let the job finished" do
-      @daemon.stop
-      @thread.join 10 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
-      assert_equal 'finished', Qs.redis.with{ |c| c.get('slow') }
+    should "shutdown and let the job and event finish" do
+      @app_daemon.stop
+      @app_thread.join 10 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
+      assert_equal 'finished', Qs.redis.with{ |c| c.get('qs-app:slow') }
+      assert_equal 'finished', Qs.redis.with{ |c| c.get('qs-app:slow:event') }
     end
 
-    should "shutdown and not let the job finished" do
-      @daemon.halt
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
-      assert_nil Qs.redis.with{ |c| c.get('slow') }
+    should "shutdown and not let the job or event finish" do
+      @app_daemon.halt
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
+      assert_nil Qs.redis.with{ |c| c.get('qs-app:slow') }
+      exp = "Qs::ShutdownError"
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
+      assert_nil Qs.redis.with{ |c| c.get('qs-app:slow:event') }
       exp = "Qs::ShutdownError"
-      assert_equal exp, Qs.redis.with{ |c| c.get('last_error') }
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
 
   end
@@ -140,86 +202,93 @@ module Qs::Daemon
     desc "with a shutdown timeout"
     setup do
       AppDaemon.shutdown_timeout 1
-      @daemon = AppDaemon.new
-      @daemon_runner = DaemonRunner.new(@daemon)
-      @thread = @daemon_runner.start
+      setup_app_and_dispatcher_daemon
 
       AppQueue.add('slow')
-      @thread.join 1 # let the daemon have time to process the job
+      Qs.publish('qs-app', 'slow')
+      @app_thread.join 1 # let the daemon have time to process the job and event
     end
 
-    should "shutdown and not let the job finished" do
-      @daemon.stop
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
-      assert_nil Qs.redis.with{ |c| c.get('slow') }
+    should "shutdown and not let the job or event finish" do
+      @app_daemon.stop
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
+      assert_nil Qs.redis.with{ |c| c.get('qs-app:slow') }
       exp = "Qs::ShutdownError"
-      assert_equal exp, Qs.redis.with{ |c| c.get('last_error') }
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
+      assert_nil Qs.redis.with{ |c| c.get('qs-app:slow:event') }
+      exp = "Qs::ShutdownError"
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
 
-    should "shutdown and not let the job finished" do
-      @daemon.halt
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
-      assert_nil Qs.redis.with{ |c| c.get('slow') }
+    should "shutdown and not let the job or event finish" do
+      @app_daemon.halt
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
+      assert_nil Qs.redis.with{ |c| c.get('qs-app:slow') }
+      exp = "Qs::ShutdownError"
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
+      assert_nil Qs.redis.with{ |c| c.get('qs-app:slow:event') }
       exp = "Qs::ShutdownError"
-      assert_equal exp, Qs.redis.with{ |c| c.get('last_error') }
+      assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
 
   end
 
-  class ShutdownWithUnprocessedRedisItemTests < SystemTests
-    desc "with a redis item that gets picked up but doesn't get processed"
+  class ShutdownWithUnprocessedQueueItemTests < SystemTests
+    desc "with a queue item that gets picked up but doesn't get processed"
     setup do
       Assert.stub(Qs::PayloadHandler, :new){ sleep 5 }
 
       AppDaemon.shutdown_timeout 1
       AppDaemon.workers 2
-      @daemon = AppDaemon.new
-      @daemon_runner = DaemonRunner.new(@daemon)
-      @thread = @daemon_runner.start
+      setup_app_and_dispatcher_daemon
 
       AppQueue.add('slow')
       AppQueue.add('slow')
       AppQueue.add('basic')
-      @thread.join 1 # let the daemon have time to process jobs
+      @app_thread.join 1 # let the daemon have time to process jobs
     end
 
-    should "shutdown and requeue the redis item" do
-      @daemon.stop
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
-      # TODO - better way to read whats on a queue
-      serialized_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 3) }
-      names = serialized_payloads.map{ |sp| Qs::Job.parse(Qs.deserialize(sp)).name }
+    should "shutdown and requeue the queue item" do
+      @app_daemon.stop
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
+      encoded_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 3) }
+      names = encoded_payloads.map{ |sp| Qs::Payload.deserialize(sp).name }
       assert_equal ['basic', 'slow', 'slow'], names
     end
 
-    should "shutdown and requeue the redis item" do
-      @daemon.halt
-      @thread.join 2 # give it time to shutdown, should be faster
-      assert_false @thread.alive?
-      # TODO - better way to read whats on a queue
-      serialized_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 3) }
-      names = serialized_payloads.map{ |sp| Qs::Job.parse(Qs.deserialize(sp)).name }
+    should "shutdown and requeue the queue item" do
+      @app_daemon.halt
+      @app_thread.join 2 # give it time to shutdown, should be faster
+      assert_false @app_thread.alive?
+      encoded_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 3) }
+      names = encoded_payloads.map{ |sp| Qs::Payload.deserialize(sp).name }
       assert_equal ['basic', 'slow', 'slow'], names
     end
 
   end
 
   class DaemonRunner
-    def initialize(daemon)
-      @daemon = daemon
-      @thread = nil
+    def initialize(app_daemon, dispatcher_daemon = nil)
+      @app_daemon = app_daemon
+      @dispatcher_daemon = dispatcher_daemon
+      @app_thread = nil
+      @dispatcher_thread = nil
     end
 
     def start
-      @thread = @daemon.start
+      @app_thread = @app_daemon.start
+      @dispatcher_thread = @dispatcher_daemon.start if @dispatcher_daemon
+      @app_thread
     end
 
     def stop
-      @daemon.halt
-      @thread.join if @thread
+      @app_daemon.halt
+      @dispatcher_daemon.halt if @dispatcher_daemon
+      @app_thread.join if @app_thread
+      @dispatcher_thread.join if @dispatcher_thread
     end
   end
 

data/test/system/queue_tests.rb

@@ -0,0 +1,87 @@
+require 'assert'
+require 'qs'
+
+require 'test/support/app_daemon'
+
+class Qs::Queue
+
+  class SystemTests < Assert::Context
+    desc "Qs::Queue"
+    setup do
+      Qs.reset!
+      @qs_test_mode = ENV['QS_TEST_MODE']
+      ENV['QS_TEST_MODE'] = nil
+      Qs.init
+
+      @event = Qs::Event.new('qs-app', 'basic')
+      @other_queue = Qs::Queue.new{ name(Factory.string) }
+      @other_queue.event(@event.channel, @event.name, Factory.string)
+    end
+    teardown do
+      Qs.redis.with do |c|
+        keys = c.keys('*qs-app*')
+        c.pipelined{ keys.each{ |k| c.del(k) } }
+      end
+      Qs.reset!
+      ENV['QS_TEST_MODE'] = @qs_test_mode
+    end
+
+  end
+
+  class SyncSubscriptionsTests < SystemTests
+    desc "sync_subscriptions"
+    setup do
+      AppQueue.sync_subscriptions
+    end
+
+    should "store subscriptions for the queue in redis" do
+      AppQueue.event_route_names.each do |route_name|
+        redis_key = Qs::Event::SubscribersRedisKey.new(route_name)
+        smembers = Qs.redis.with{ |c| c.smembers(redis_key) }
+        assert_includes AppQueue.name, smembers
+      end
+    end
+
+    should "allow adding a new queues subscriptions but preserve the existing" do
+      @other_queue.sync_subscriptions
+
+      smembers = Qs.redis.with{ |c| c.smembers(@event.subscribers_redis_key) }
+      assert_equal 2, smembers.size
+      assert_includes AppQueue.name,     smembers
+      assert_includes @other_queue.name, smembers
+    end
+
+    should "remove subscriptions if a queue no longer subscribes to the event" do
+      route_names = AppQueue.event_route_names.reject{ |n| n == @event.route_name }
+      Assert.stub(AppQueue, :event_route_names){ route_names }
+      AppQueue.sync_subscriptions
+
+      redis_key = Qs::Event.new('qs-app', 'basic').subscribers_redis_key
+      smembers = Qs.redis.with{ |c| c.smembers(redis_key) }
+      assert_not_includes AppQueue.name, smembers
+    end
+
+  end
+
+  class ClearSubscriptionsTests < SystemTests
+    desc "clear_subscriptions"
+    setup do
+      AppQueue.sync_subscriptions
+      @other_queue.sync_subscriptions
+      AppQueue.clear_subscriptions
+    end
+
+    should "remove the queue from all of its events subscribers" do
+      AppQueue.event_route_names.each do |route_name|
+        redis_key = Qs::Event::SubscribersRedisKey.new(route_name)
+        smembers = Qs.redis.with{ |c| c.smembers(redis_key) }
+        assert_not_includes AppQueue.name, smembers
+      end
+
+      smembers = Qs.redis.with{ |c| c.smembers(@event.subscribers_redis_key) }
+      assert_equal [@other_queue.name], smembers
+    end
+
+  end
+
+end

data/test/unit/client_tests.rb

@@ -48,10 +48,12 @@ module Qs::Client
     subject{ @client }
 
     should have_readers :redis_config, :redis
-    should have_imeths :enqueue, :push
+    should have_imeths :enqueue, :publish, :publish_as, :push
     should have_imeths :block_dequeue
     should have_imeths :append, :prepend
     should have_imeths :clear
+    should have_imeths :sync_subscriptions, :clear_subscriptions
+    should have_imeths :event_subscribers
 
     should "know its redis config" do
       assert_equal @redis_config, subject.redis_config
@@ -63,16 +65,51 @@ module Qs::Client
 
     should "build a job, enqueue it and return it using `enqueue`" do
       result = subject.enqueue(@queue, @job_name, @job_params)
-      enqueued_job = subject.enqueued_jobs.last
-      assert_equal @job_name,   enqueued_job.name
-      assert_equal @job_params, enqueued_job.params
-      assert_equal enqueued_job, result
-    end
-
-    should "default the job's params to an empty hash using `enqueue`" do
-      subject.enqueue(@queue, @job_name)
-      enqueued_job = subject.enqueued_jobs.last
-      assert_equal({}, enqueued_job.params)
+      call = subject.enqueue_calls.last
+      assert_equal @queue,      call.queue
+      assert_equal @job_name,   call.job.name
+      assert_equal @job_params, call.job.params
+      assert_equal call.job,    result
+    end
+
+    should "enqueue a dispatch job and return its event using `publish`" do
+      event_channel = Factory.string
+      event_name    = Factory.string
+      event_params  = @job_params
+      result = subject.publish(event_channel, event_name, event_params)
+
+      call = subject.enqueue_calls.last
+      assert_equal Qs.dispatcher_queue, call.queue
+
+      dispatch_job = Factory.dispatch_job({
+        :event_channel => event_channel,
+        :event_name    => event_name,
+        :event_params  => event_params
+      })
+      assert_equal dispatch_job.name,   call.job.name
+      assert_equal dispatch_job.params, call.job.params
+      assert_equal call.job.event,      result
+    end
+
+    should "enqueue a dispatch job with a custom publisher using `publish_as`" do
+      publisher = Factory.string
+      channel   = Factory.string
+      name      = Factory.string
+      params    = @job_params
+      result = subject.publish_as(publisher, channel, name, params)
+
+      call = subject.enqueue_calls.last
+      assert_equal Qs.dispatcher_queue, call.queue
+
+      dispatch_job = Factory.dispatch_job({
+        :event_channel   => channel,
+        :event_name      => name,
+        :event_params    => params,
+        :event_publisher => publisher
+      })
+      assert_equal dispatch_job.name,   call.job.name
+      assert_equal dispatch_job.params, call.job.params
+      assert_equal call.job.event,      result
     end
 
     should "raise a not implemented error using `push`" do
@@ -88,8 +125,8 @@ module Qs::Client
       @connection_spy = HellaRedis::ConnectionSpy.new(@client.redis_config)
       Assert.stub(@client, :redis){ @connection_spy }
 
-      @queue_redis_key    = Factory.string
-      @serialized_payload = Factory.string
+      @queue_redis_key = Factory.string
+      @encoded_payload = Factory.string
     end
 
     should "block pop from the front of a list using `block_dequeue`" do
@@ -101,22 +138,22 @@ module Qs::Client
       assert_equal args,   call.args
     end
 
-    should "add a serialized payload to the end of a list using `append`" do
-      subject.append(@queue_redis_key, @serialized_payload)
+    should "add a encoded payload to the end of a list using `append`" do
+      subject.append(@queue_redis_key, @encoded_payload)
 
       call = @connection_spy.redis_calls.last
-      assert_equal :lpush,              call.command
-      assert_equal @queue_redis_key,    call.args.first
-      assert_equal @serialized_payload, call.args.last
+      assert_equal :lpush,           call.command
+      assert_equal @queue_redis_key, call.args.first
+      assert_equal @encoded_payload, call.args.last
     end
 
-    should "add a serialized payload to the front of a list using `prepend`" do
-      subject.prepend(@queue_redis_key, @serialized_payload)
+    should "add a encoded payload to the front of a list using `prepend`" do
+      subject.prepend(@queue_redis_key, @encoded_payload)
 
       call = @connection_spy.redis_calls.last
-      assert_equal :rpush,              call.command
-      assert_equal @queue_redis_key,    call.args.first
-      assert_equal @serialized_payload, call.args.last
+      assert_equal :rpush,           call.command
+      assert_equal @queue_redis_key, call.args.first
+      assert_equal @encoded_payload, call.args.last
     end
 
     should "del a list using `clear`" do
@@ -134,6 +171,96 @@ module Qs::Client
       assert_equal :ping, call.command
     end
 
+    should "return the events subscriber set using `event_subscribers`" do
+      smembers_key = nil
+      smembers = Factory.integer(3).times.map{ Factory.string }
+      Assert.stub(@connection_spy.redis_spy, :smembers) do |key|
+        smembers_key = key
+        smembers
+      end
+
+      event = Factory.event
+      result = subject.event_subscribers(event)
+
+      assert_equal event.subscribers_redis_key, smembers_key
+      assert_equal smembers, result
+    end
+
+  end
+
+  class SubscriptionsSetupTests < RedisCallTests
+    setup do
+      @event_subs_keys = Factory.integer(3).times.map{ Factory.string }
+      @keys_pattern = nil
+      Assert.stub(@connection_spy.redis_spy, :keys) do |pattern|
+        @keys_pattern = pattern
+        @event_subs_keys
+      end
+    end
+
+  end
+
+  class SyncSubscriptionsTests < SubscriptionsSetupTests
+    desc "sync_subscriptions"
+    setup do
+      Factory.integer(3).times.map{ @queue.event_route_names << Factory.string }
+      subject.sync_subscriptions(@queue)
+    end
+
+    should "run in a pipelined transaction" do
+      calls = @connection_spy.redis_calls[0, 2]
+      assert_equal [:pipelined, :multi], calls.map(&:command)
+    end
+
+    should "find all event subscribers keys" do
+      assert_equal Qs::Event::SubscribersRedisKey.new('*'), @keys_pattern
+    end
+
+    should "remove the queue from all events subscribers first" do
+      calls = @connection_spy.redis_calls[2, @event_subs_keys.size]
+      assert_equal @event_subs_keys.size, calls.size
+      assert_equal [:srem], calls.map(&:command).uniq
+      exp = @event_subs_keys.map{ |key| [key, @queue.name] }
+      assert_equal exp, calls.map(&:args)
+    end
+
+    should "remove and add the queue from events subscribers" do
+      start_at = 2 + @event_subs_keys.size
+      calls = @connection_spy.redis_calls[start_at..-1]
+      exp = @queue.event_route_names.size
+      assert_equal exp, calls.size
+      assert_equal [:sadd], calls.map(&:command).uniq
+      exp = @queue.event_route_names.map do |name|
+        [Qs::Event::SubscribersRedisKey.new(name), @queue.name]
+      end
+      assert_equal exp, calls.map(&:args)
+    end
+
+  end
+
+  class ClearSubscriptionsTests < SubscriptionsSetupTests
+    desc "clear_subscriptions"
+    setup do
+      subject.clear_subscriptions(@queue)
+    end
+
+    should "run in a pipelined transaction" do
+      calls = @connection_spy.redis_calls[0, 2]
+      assert_equal [:pipelined, :multi], calls.map(&:command)
+    end
+
+    should "find all event subscribers keys" do
+      assert_equal Qs::Event::SubscribersRedisKey.new('*'), @keys_pattern
+    end
+
+    should "remove the queue from all events subscribers" do
+      calls = @connection_spy.redis_calls[2..-1]
+      assert_equal @event_subs_keys.size, calls.size
+      assert_equal [:srem], calls.map(&:command).uniq
+      exp = @event_subs_keys.map{ |key| [key, @queue.name] }
+      assert_equal exp, calls.map(&:args)
+    end
+
   end
 
   class QsClientTests < UnitTests
@@ -167,25 +294,25 @@ module Qs::Client
       assert_equal @connection_spy, subject.redis
     end
 
-    should "add jobs to the queue's redis list using `enqueue`" do
+    should "add jobs to the queues redis list using `enqueue`" do
       subject.enqueue(@queue, @job_name, @job_params)
 
       call = @connection_spy.redis_calls.last
       assert_equal :lpush, call.command
       assert_equal @queue.redis_key, call.args.first
-      payload = Qs.deserialize(call.args.last)
-      assert_equal @job_name,   payload['name']
-      assert_equal @job_params, payload['params']
+      job = Qs::Payload.deserialize(call.args.last)
+      assert_equal @job_name,   job.name
+      assert_equal @job_params, job.params
     end
 
-    should "add payloads to the queue's redis list using `push`" do
-      job = Qs::Job.new(@job_name, @job_params)
-      subject.push(@queue.name, job.to_payload)
+    should "add a payload hash to the queues redis list using `push`" do
+      payload_hash = { Factory.string => Factory.string }
+      subject.push(@queue.name, payload_hash)
 
       call = @connection_spy.redis_calls.last
       assert_equal :lpush, call.command
       assert_equal @queue.redis_key, call.args.first
-      assert_equal Qs.serialize(job.to_payload), call.args.last
+      assert_equal Qs.encode(payload_hash), call.args.last
     end
 
   end
@@ -206,10 +333,10 @@ module Qs::Client
   class TestClientInitTests < TestClientTests
     desc "when init"
     setup do
-      @serialized_payload = nil
-      Assert.stub(Qs, :serialize){ |payload| @serialized_payload = payload }
-
-      @job = Qs::Job.new(@job_name, @job_params)
+      @encoded_hash = nil
+      Assert.stub(Qs, :encode){ |hash| @encoded_hash = hash }
+      @serialized_job = nil
+      Assert.stub(Qs::Payload, :serialize){ |job| @serialized_job = job }
 
       @client = @client_class.new(@redis_config)
     end
@@ -237,24 +364,34 @@ module Qs::Client
       assert_equal job, result
     end
 
-    should "serialize the jobs when enqueueing" do
+    should "serialize the job when enqueueing" do
       subject.enqueue(@queue, @job_name, @job_params)
 
       job = @queue.enqueued_jobs.last
-      assert_equal job.to_payload, @serialized_payload
+      assert_equal job, @serialized_job
     end
 
-    should "track all the payloads pushed onto a queue" do
-      subject.push(@queue.name, @job.to_payload)
+    should "track all the payload hashes pushed onto a queue" do
+      payload_hash = { Factory.string => Factory.string }
+      subject.push(@queue.name, payload_hash)
 
       pushed_item = subject.pushed_items.last
       assert_instance_of Qs::TestClient::PushedItem, pushed_item
-      assert_equal @queue.name,     pushed_item.queue_name
-      assert_equal @job.to_payload,  pushed_item.payload
+      assert_equal @queue.name,  pushed_item.queue_name
+      assert_equal payload_hash, pushed_item.payload_hash
+    end
+
+    should "encode the payload hashes when pushing them onto a queue" do
+      payload_hash = { Factory.string => Factory.string }
+      subject.push(@queue.name, payload_hash)
+
+      pushed_item = subject.pushed_items.last
+      assert_equal pushed_item.payload_hash, @encoded_hash
     end
 
     should "clear its pushed items when reset" do
-      subject.push(@queue.name, @job.to_payload)
+      payload_hash = { Factory.string => Factory.string }
+      subject.push(@queue.name, payload_hash)
       assert_not_empty subject.pushed_items
       subject.reset!
       assert_empty subject.pushed_items
@@ -265,12 +402,14 @@ module Qs::Client
   class FakeClient
     include Qs::Client
 
-    attr_reader :enqueued_jobs
+    attr_reader :enqueue_calls
 
     def enqueue!(queue, job)
-      @enqueued_jobs ||= []
-      @enqueued_jobs << job
+      @enqueue_calls ||= []
+      EnqueueCall.new(queue, job).tap{ |c| @enqueue_calls << c }
     end
+
+    EnqueueCall = Struct.new(:queue, :job)
   end
 
 end