qs 0.6.1 → 0.7.0

data/test/unit/message_handler_tests.rb

@@ -211,7 +211,7 @@ module Qs::MessageHandler
       @handler.qs_run
     end
 
-    should "call `run!` and it's callbacks" do
+    should "call `run!` and its callbacks" do
       assert_equal 6,  subject.first_before_run_call_order
       assert_equal 7,  subject.second_before_run_call_order
       assert_equal 8,  subject.run_call_order
@@ -236,12 +236,25 @@ module Qs::MessageHandler
       assert_equal @runner.params, subject.instance_eval{ params }
     end
 
+    should "call to the runner for its halt helper" do
+      capture_runner_meth_args_for(:halt)
+      subject.instance_eval{ halt }
+
+      assert_equal [], @meth_args
+    end
+
     private
 
     def stub_runner_with_something_for(meth)
       Assert.stub(@runner, meth){ @something }
     end
 
+    def capture_runner_meth_args_for(meth)
+      Assert.stub(@runner, meth) do |*args|
+        @meth_args = args
+      end
+    end
+
   end
 
   class TestMessageHandler

data/test/unit/process_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 require 'qs/process'
 
 require 'qs/daemon'
+require 'qs/io_pipe'
 require 'test/support/pid_file_spy'
 
 class Qs::Process
@@ -9,22 +10,31 @@ class Qs::Process
   class UnitTests < Assert::Context
     desc "Qs::Process"
     setup do
+      @current_env_skip_daemonize = ENV['QS_SKIP_DAEMONIZE']
+      ENV.delete('QS_SKIP_DAEMONIZE')
+
       @process_class = Qs::Process
     end
+    teardown do
+      ENV['QS_SKIP_DAEMONIZE'] = @current_env_skip_daemonize
+    end
     subject{ @process_class }
 
     should "know its wait for signals timeout" do
       assert_equal 15, WAIT_FOR_SIGNALS_TIMEOUT
     end
 
+    should "know its signal strings" do
+      assert_equal 'H', HALT
+      assert_equal 'S', STOP
+      assert_equal 'R', RESTART
+    end
+
   end
 
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @current_env_skip_daemonize = ENV['QS_SKIP_DAEMONIZE']
-      ENV.delete('QS_SKIP_DAEMONIZE')
-
       @daemon_spy = DaemonSpy.new
 
       @pid_file_spy = PIDFileSpy.new(Factory.integer)
@@ -37,9 +47,6 @@ class Qs::Process
 
       @process = @process_class.new(@daemon_spy)
     end
-    teardown do
-      ENV['QS_SKIP_DAEMONIZE'] = @current_env_skip_daemonize
-    end
     subject{ @process }
 
     should have_readers :daemon, :name
@@ -51,7 +58,9 @@ class Qs::Process
     end
 
     should "know its name, pid file, signal io and restart cmd" do
-      assert_equal "qs: #{@daemon_spy.process_label}", subject.name
+      exp = "qs: #{@daemon_spy.process_label}"
+      assert_equal exp, subject.name
+
       assert_equal @pid_file_spy, subject.pid_file
       assert_instance_of Qs::IOPipe, subject.signal_io
       assert_equal @restart_cmd_spy, subject.restart_cmd
@@ -109,12 +118,12 @@ class Qs::Process
       @wait_timeout = nil
       Assert.stub(@process.signal_io, :wait) do |timeout|
         @wait_timeout = timeout
-        sleep 0.1
+        sleep 2*JOIN_SECONDS
         false
       end
 
       @thread = Thread.new{ @process.run }
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
     teardown do
       # manually unstub or the process thread will hang forever
@@ -177,7 +186,7 @@ class Qs::Process
     setup do
       Assert.stub(@process, :daemonize?){ true }
       @thread = Thread.new{ @process.run }
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
 
     should "daemonize the process" do
@@ -190,8 +199,9 @@ class Qs::Process
     desc "and run with a halt signal"
     setup do
       @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
       @process.signal_io.write(HALT)
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
 
     should "halt its daemon" do
@@ -217,8 +227,9 @@ class Qs::Process
     desc "and run with a stop signal"
     setup do
       @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
       @process.signal_io.write(STOP)
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
 
     should "stop its daemon" do
@@ -244,8 +255,9 @@ class Qs::Process
     desc "and run with a restart signal"
     setup do
       @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
       @process.signal_io.write(RESTART)
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
 
     should "stop its daemon" do
@@ -253,10 +265,6 @@ class Qs::Process
       assert_equal [true], @daemon_spy.stop_args
     end
 
-    should "set the env var to skip daemonize" do
-      assert_equal 'yes', ENV['QS_SKIP_DAEMONIZE']
-    end
-
     should "run the restart cmd" do
       assert_true @restart_cmd_spy.run_called
     end
@@ -266,15 +274,16 @@ class Qs::Process
   class RunWithDaemonCrashTests < RunSetupTests
     desc "and run with the daemon crashing"
     setup do
-      # lower the time it sleeps so it loops and restarts the daemon quicker
       Assert.stub(@process.signal_io, :wait) do |timeout|
-        sleep 0.1
+        sleep JOIN_SECONDS * 0.5 # ensure this has time to run before the thread
+                                 # joins below
         false
       end
 
       @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
       @daemon_spy.start_called = false
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
     teardown do
       # manually unstub or the process thread will hang forever
@@ -294,7 +303,7 @@ class Qs::Process
       Assert.stub(::Signal, :trap){ raise ArgumentError }
 
       @thread = Thread.new{ @process.run }
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
     end
 
     should "start normally" do
@@ -343,10 +352,26 @@ class Qs::Process
       assert_equal [Gem.ruby, $0, ARGV].flatten, subject.argv
     end
 
-    should "change the dir and run a kernel exec when run" do
-      subject.run
-      assert_equal [subject.dir], @chdir_called_with
-      assert_equal subject.argv,  @exec_called_with
+    if RUBY_VERSION == '1.8.7'
+
+      should "set env vars, change the dir and kernel exec when run" do
+        subject.run
+
+        assert_equal 'yes', ENV['QS_SKIP_DAEMONIZE']
+        assert_equal [subject.dir], @chdir_called_with
+        assert_equal subject.argv,  @exec_called_with
+      end
+
+    else
+
+      should "kernel exec when run" do
+        subject.run
+
+        env     = { 'QS_SKIP_DAEMONIZE' => 'yes' }
+        options = { :chdir => subject.dir }
+        assert_equal ([env] + subject.argv + [options]), @exec_called_with
+      end
+
     end
 
   end

data/test/unit/qs_runner_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'qs/qs_runner'
 
+require 'much-timeout'
 require 'qs'
 require 'qs/message_handler'
 
@@ -23,6 +24,10 @@ class Qs::QsRunner
       assert_true subject < Qs::Runner
     end
 
+    should "know its TimeoutInterrupt" do
+      assert_true TimeoutInterrupt < Interrupt
+    end
+
   end
 
   class InitTests < UnitTests
@@ -47,9 +52,9 @@ class Qs::QsRunner
   class RunSetupTests < InitTests
     desc "and run"
     setup do
-      @timeout_called_with = nil
-      Assert.stub(OptionalTimeout, :new) do |*args, &block|
-        @timeout_called_with = args
+      @optional_timeout_called_with = nil
+      Assert.stub(MuchTimeout, :optional_timeout) do |*args, &block|
+        @optional_timeout_called_with = args
         block.call
       end
     end
@@ -63,7 +68,8 @@ class Qs::QsRunner
     end
 
     should "run the handler in an optional timeout" do
-      assert_equal [@runner.timeout], @timeout_called_with
+      exp = [@runner.timeout, TimeoutInterrupt]
+      assert_equal exp, @optional_timeout_called_with
     end
 
     should "run the handler's before callbacks" do
@@ -83,50 +89,124 @@ class Qs::QsRunner
 
   end
 
-  class RunWithTimeoutErrorTests < RunSetupTests
+  class RunWithInitHaltTests < UnitTests
+    desc "with a handler that halts on init"
     setup do
-      Assert.stub(OptionalTimeout, :new){ raise Qs::TimeoutError }
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'init'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
     end
+    subject{ @runner }
 
-    should "raise a timeout error with a good message" do
-      exception = nil
-      begin; @runner.run; rescue StandardError => exception; end
+    should "run the before and after callbacks despite the halt" do
+      assert_not_nil @handler.first_before_call_order
+      assert_not_nil @handler.second_before_call_order
+      assert_not_nil @handler.first_after_call_order
+      assert_not_nil @handler.second_after_call_order
+    end
 
-      assert_kind_of Qs::TimeoutError, exception
-      exp = "#{@handler_class} timed out (#{@runner.timeout}s)"
-      assert_equal exp, exception.message
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.init_call_order
+      assert_nil @handler.run_call_order
     end
 
   end
 
-  class OptionalTimeoutTests < UnitTests
-    desc "OptionalTimeout"
+  class RunWithRunHaltTests < UnitTests
+    desc "when run with a handler that halts on run"
     setup do
-      @timeout_called_with = nil
-      Assert.stub(SystemTimer, :timeout_after) do |*args, &block|
-        @timeout_called_with = args
-        block.call
-      end
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'run'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
     end
-    subject{ OptionalTimeout }
+    subject{ @runner }
 
-    should have_imeths :new
+    should "run the before and after callbacks despite the halt" do
+      assert_not_nil @handler.first_before_call_order
+      assert_not_nil @handler.second_before_call_order
+      assert_not_nil @handler.first_after_call_order
+      assert_not_nil @handler.second_after_call_order
+    end
 
-    should "use a system timer timeout when provided a non-`nil` value" do
-      value = Factory.integer
-      block_run = false
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.init_call_order
+      assert_not_nil @handler.run_call_order
+    end
 
-      subject.new(value){ block_run = true }
-      assert_equal [value, Qs::TimeoutError], @timeout_called_with
-      assert_true block_run
+  end
+
+  class RunWithBeforeHaltTests < UnitTests
+    desc "when run with a handler that halts in an after callback"
+    setup do
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'before'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
     end
+    subject{ @runner }
 
-    should "call the block when provided a `nil` value" do
-      block_run = false
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.first_before_call_order
+      assert_nil @handler.second_before_call_order
+    end
 
-      subject.new(nil){ block_run = true }
-      assert_nil @timeout_called_with
-      assert_true block_run
+    should "not run the after callbacks b/c of the halt" do
+      assert_nil @handler.first_after_call_order
+      assert_nil @handler.second_after_call_order
+    end
+
+    should "not run the handler's init and run b/c of the halt" do
+      assert_nil @handler.init_call_order
+      assert_nil @handler.run_call_order
+    end
+
+  end
+
+  class RunWithAfterHaltTests < UnitTests
+    desc "when run with a handler that halts in an after callback"
+    setup do
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'after'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+    subject{ @runner }
+
+    should "run the before callback despite the halt" do
+      assert_not_nil @handler.first_before_call_order
+      assert_not_nil @handler.second_before_call_order
+    end
+
+    should "run the handler's init and run despite the halt" do
+      assert_not_nil @handler.init_call_order
+      assert_not_nil @handler.run_call_order
+    end
+
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.first_after_call_order
+      assert_nil @handler.second_after_call_order
+    end
+
+  end
+
+  class RunWithTimeoutInterruptTests < RunSetupTests
+    setup do
+      Assert.stub(MuchTimeout, :optional_timeout){ raise TimeoutInterrupt }
+    end
+
+    should "raise a timeout error with a good message" do
+      exception = assert_raises(Qs::TimeoutError) do
+        @runner.run
+      end
+
+      exp = "#{@handler_class} timed out (#{@runner.timeout}s)"
+      assert_equal exp, exception.message
     end
 
   end
@@ -141,24 +221,30 @@ class Qs::QsRunner
 
     timeout Factory.integer
 
-    before{ @first_before_call_order = next_call_order }
+    before{ @first_before_call_order = next_call_order; halt_if('before') }
     before{ @second_before_call_order = next_call_order }
 
-    after{ @first_after_call_order = next_call_order }
+    after{ @first_after_call_order = next_call_order; halt_if('after') }
     after{ @second_after_call_order = next_call_order }
 
     def init!
       @init_call_order = next_call_order
+      halt_if('init')
     end
 
     def run!
       @run_call_order = next_call_order
+      halt_if('run')
     end
 
     private
 
     def next_call_order; @order ||= 0; @order += 1; end
 
+    def halt_if(value)
+      halt if params['halt'] == value
+    end
+
   end
 
 end

data/test/unit/qs_tests.rb

@@ -2,7 +2,6 @@ require 'assert'
 require 'qs'
 
 require 'hella-redis/connection_spy'
-require 'ns-options/assert_macros'
 require 'qs/queue'
 
 module Qs
@@ -24,7 +23,7 @@ module Qs
     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 :client, :redis, :redis_connect_hash
     should have_imeths :dispatcher_queue, :dispatcher_job_name
     should have_imeths :event_publisher
     should have_imeths :published_events
@@ -33,20 +32,23 @@ module Qs
       assert_instance_of Config, subject.config
     end
 
-    should "allow configuring its config" do
+    should "configure its config" do
       yielded = nil
       subject.configure{ |c| yielded = c }
       assert_same subject.config, yielded
     end
 
-    should "not have a client or redis connection by default" do
-      assert_nil subject.client
+    should "have a null client by default" do
+      assert_instance_of NullClient, subject.client
+    end
+
+    should "not have a redis connection by default" do
       assert_nil subject.redis
     end
 
     should "know its redis config" do
-      expected = subject.config.redis.to_hash
-      assert_equal expected, subject.redis_config
+      exp = subject.config.redis_connect_hash
+      assert_equal exp, subject.redis_connect_hash
     end
 
   end
@@ -56,9 +58,9 @@ module Qs
     setup do
       @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
+      @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|
@@ -73,30 +75,26 @@ module Qs
       @module.init
     end
 
-    should "set its configured redis url" do
-      expected = RedisUrl.new(
-        subject.config.redis.ip,
-        subject.config.redis.port,
-        subject.config.redis.db
-      )
-      assert_equal expected, subject.config.redis.url
+    should "validate its config" do
+      assert_true subject.config.valid?
     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
+
+      c   = subject.config
+      spy = @dispatcher_queue_spy
+      assert_equal c.dispatcher_queue_class,            spy.queue_class
+      assert_equal c.dispatcher_queue_name,             spy.queue_name
+      assert_equal c.dispatcher_job_name,               spy.job_name
+      assert_equal c.dispatcher_job_handler_class_name, spy.job_handler_class_name
     end
 
     should "build a client" do
-      assert_equal @client_spy,          subject.client
-      assert_equal @client_spy.redis,    subject.redis
-      assert_equal subject.redis_config, @client_spy.redis_config
+      assert_equal @client_spy,       subject.client
+      assert_equal @client_spy.redis, subject.redis
+
+      assert_equal subject.redis_connect_hash, @client_spy.redis_connect_hash
     end
 
     should "call enqueue on its client using `enqueue`" do
@@ -149,14 +147,12 @@ module Qs
 
     should "use the configured encoder using `encode`" do
       value = Factory.integer
-      result = subject.encode(value)
-      assert_equal value.to_s, result
+      assert_equal value.to_s, subject.encode(value)
     end
 
     should "use the configured decoder using `decode`" do
       value = Factory.integer.to_s
-      result = subject.decode(value)
-      assert_equal value.to_i, result
+      assert_equal value.to_i, subject.decode(value)
     end
 
     should "demeter its clients subscription methods" do
@@ -180,24 +176,28 @@ module Qs
     end
 
     should "know its dispatcher job name and event publisher" do
-      exp = subject.config.dispatcher.job_name
+      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
+      exp = Factory.integer(3).times.map{ Factory.string }
+      Assert.stub(subject.dispatcher_queue, :published_events){ exp }
+
+      assert_equal exp, subject.published_events
     end
 
     should "not reset its attributes when init again" do
+      config = subject.config
       queue  = subject.dispatcher_queue
       client = subject.client
       redis  = subject.redis
       subject.init
+
+      assert_same config, subject.config
       assert_same queue,  subject.dispatcher_queue
       assert_same client, subject.client
       assert_same redis,  subject.redis
@@ -205,10 +205,11 @@ module Qs
 
     should "reset itself using `reset!`" do
       subject.reset!
-      assert_nil subject.config.redis.url
+
+      assert_false subject.config.valid?
       assert_nil subject.dispatcher_queue
-      assert_nil subject.client
       assert_nil subject.redis
+      assert_instance_of NullClient, subject.client
       assert_raises(NoMethodError){ subject.encode(Factory.integer) }
       assert_raises(NoMethodError){ subject.decode(Factory.integer) }
     end
@@ -216,54 +217,115 @@ module Qs
   end
 
   class ConfigTests < UnitTests
-    include NsOptions::AssertMacros
-
     desc "Config"
     setup do
       @config = Config.new
     end
     subject{ @config }
 
-    should have_options :encoder, :decoder, :timeout
-    should have_options :event_publisher
-    should have_namespace :dispatcher, :redis
-    should have_accessors :dispatcher_queue_class
+    should have_accessors :encoder, :decoder, :timeout, :event_publisher
+    should have_accessors :dispatcher_queue_class, :dispatcher_queue_name
+    should have_accessors :dispatcher_job_name, :dispatcher_job_handler_class_name
+    should have_accessors :redis_ip, :redis_port, :redis_db, :redis_ns
+    should have_accessors :redis_driver, :redis_timeout, :redis_size, :redis_url
+    should have_imeths :redis_connect_hash, :valid?, :validate!
 
-    should "know its default decoder/encoder" do
+    should "know its default attr values" do
       payload = { Factory.string => Factory.string }
 
       exp = JSON.dump(payload)
-      encoded_payload = subject.encoder.call(payload)
-      assert_equal exp, encoded_payload
-      exp = JSON.load(exp)
-      assert_equal exp, subject.decoder.call(encoded_payload)
+      assert_equal exp, Config::DEFAULT_ENCODER.call(payload)
+
+      encoded_payload = exp
+      exp = JSON.load(encoded_payload)
+      assert_equal exp, Config::DEFAULT_DECODER.call(encoded_payload)
+
+      assert_equal Queue,              Config::DEFAULT_DISPATCHER_QUEUE_CLASS
+      assert_equal 'dispatcher',       Config::DEFAULT_DISPATCHER_QUEUE_NAME
+      assert_equal 'run_dispatch_job', Config::DEFAULT_DISPATCHER_JOB_NAME
+
+      exp = DispatcherQueue::RunDispatchJob.to_s
+      assert_equal exp, Config::DEFAULT_DISPATCHER_JOB_HANDLER_CLASS_NAME
+
+      assert_equal '127.0.0.1', Config::DEFAULT_REDIS_IP
+      assert_equal 6379,        Config::DEFAULT_REDIS_PORT
+      assert_equal 0,           Config::DEFAULT_REDIS_DB
+      assert_equal 'qs',        Config::DEFAULT_REDIS_NS
+      assert_equal 'ruby',      Config::DEFAULT_REDIS_DRIVER
+      assert_equal 1,           Config::DEFAULT_REDIS_TIMEOUT
+      assert_equal 4,           Config::DEFAULT_REDIS_SIZE
     end
 
-    should "know its default timeout" do
+    should "default its attrs" do
+      c = subject.class
+
+      assert_equal c::DEFAULT_ENCODER, subject.encoder
+      assert_equal c::DEFAULT_DECODER, subject.decoder
+
       assert_nil subject.timeout
+      assert_nil subject.event_publisher
+
+      assert_equal c::DEFAULT_DISPATCHER_QUEUE_CLASS, subject.dispatcher_queue_class
+      assert_equal c::DEFAULT_DISPATCHER_QUEUE_NAME,  subject.dispatcher_queue_name
+      assert_equal c::DEFAULT_DISPATCHER_JOB_NAME,    subject.dispatcher_job_name
+
+      exp = c::DEFAULT_DISPATCHER_JOB_HANDLER_CLASS_NAME
+      assert_equal exp, subject.dispatcher_job_handler_class_name
+
+      assert_equal c::DEFAULT_REDIS_IP,      subject.redis_ip
+      assert_equal c::DEFAULT_REDIS_PORT,    subject.redis_port
+      assert_equal c::DEFAULT_REDIS_DB,      subject.redis_db
+      assert_equal c::DEFAULT_REDIS_NS,      subject.redis_ns
+      assert_equal c::DEFAULT_REDIS_DRIVER,  subject.redis_driver
+      assert_equal c::DEFAULT_REDIS_TIMEOUT, subject.redis_timeout
+      assert_equal c::DEFAULT_REDIS_SIZE,    subject.redis_size
+
+      assert_nil subject.redis_url
     end
 
-    should "not have a default event publisher" do
-      assert_nil subject.event_publisher
+    should "know its redis connect hash" do
+      exp = {
+        :ip       => subject.redis_ip,
+        :port     => subject.redis_port,
+        :db       => subject.redis_db,
+        :redis_ns => subject.redis_ns,
+        :driver   => subject.redis_driver,
+        :timeout  => subject.redis_timeout,
+        :size     => subject.redis_size,
+        :url      => subject.redis_url
+      }
+      assert_equal exp, subject.redis_connect_hash
     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
+    should "not be valid until validate! has been called" do
+      assert_false subject.valid?
+
+      subject.validate!
+      assert_true subject.valid?
     end
 
-    should "know its default redis options" do
-      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
-      assert_equal 'ruby',      subject.redis.driver
-      assert_equal 1,           subject.redis.timeout
-      assert_equal 4,           subject.redis.size
-      assert_nil subject.redis.url
+    should "set its redis url on validate!" do
+      assert_nil subject.redis_url
+      subject.validate!
+
+      exp = RedisUrl.new(subject.redis_ip, subject.redis_port, subject.redis_db)
+      assert_equal exp, subject.redis_url
+    end
+
+    should "only be able to be validated once" do
+      subject.validate!
+
+      exp = RedisUrl.new(subject.redis_ip, subject.redis_port, subject.redis_db)
+      assert_equal exp, subject.redis_url
+
+      new_ip = Factory.string
+      subject.redis_ip = new_ip
+      subject.validate!
+
+      orig_exp = exp
+      new_exp  = RedisUrl.new(new_ip, subject.redis_port, subject.redis_db)
+      assert_not_equal new_exp, subject.redis_url
+      assert_equal orig_exp, subject.redis_url
     end
 
   end
@@ -276,8 +338,8 @@ module Qs
       ip   = Factory.string
       port = Factory.integer
       db   = Factory.integer
-      expected = "redis://#{ip}:#{port}/#{db}"
-      assert_equal expected, subject.new(ip, port, db)
+      exp = "redis://#{ip}:#{port}/#{db}"
+      assert_equal exp, subject.new(ip, port, db)
     end
 
     should "not return a url with an ip, port or db" do
@@ -288,6 +350,49 @@ module Qs
 
   end
 
+  class NullClientTests < UnitTests
+    desc "NullClient"
+    setup do
+      @null_client = NullClient.new
+    end
+    subject{ @null_client }
+
+    should have_imeths :enqueue, :publish, :publish_as, :push
+    should have_imeths :sync_subscriptions, :clear_subscriptions
+    should have_imeths :event_subscribers
+
+    should "raise uninitialized errors" do
+      queue      = Qs::Queue.new{ name Factory.string }
+      job_name   = Factory.string
+      job_params = { Factory.string => Factory.string }
+      assert_raises(UninitializedError) do
+        subject.enqueue(queue, job_name, job_params)
+      end
+
+      event_channel = Factory.string
+      event_name    = Factory.string
+      event_params  = { Factory.string => Factory.string }
+      assert_raises(UninitializedError) do
+        subject.publish(event_channel, event_name, event_params)
+      end
+
+      event_publisher = Factory.string
+      assert_raises(UninitializedError) do
+        subject.publish_as(event_publisher, event_channel, event_name, event_params)
+      end
+
+      payload = { Factory.string => Factory.string }
+      assert_raises(UninitializedError){ subject.push(queue.name, payload) }
+
+      assert_raises(UninitializedError){ subject.sync_subscriptions(queue) }
+      assert_raises(UninitializedError){ subject.clear_subscriptions(queue) }
+
+      event = Factory.event
+      assert_raises(UninitializedError){ subject.event_subscribers(event) }
+    end
+
+  end
+
   class DispatcherQueueSpy
     attr_reader :queue_class, :queue_name
     attr_reader :job_name, :job_handler_class_name
@@ -302,17 +407,17 @@ module Qs
   end
 
   class ClientSpy
-    attr_reader :redis_config, :redis
+    attr_reader :redis_connect_hash, :redis
     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    = []
+      @redis_connect_hash = redis_confg
+      @redis              = Factory.string
+      @enqueue_calls      = []
+      @publish_calls      = []
+      @push_calls         = []
       @sync_subscriptions_calls  = []
       @clear_subscriptions_calls = []
       @event_subscribers_calls   = []