qs 0.6.1 → 0.7.0

data/test/system/queue_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'qs'
 
-require 'test/support/app_daemon'
+require 'test/support/app_queue'
 
 class Qs::Queue
 

data/test/unit/cli_tests.rb

@@ -123,8 +123,8 @@ class Qs::CLI
     end
 
     should "output the error with the help" do
-      expected = "#{@command.inspect} is not a valid command"
-      assert_includes expected, @kernel_spy.output
+      exp = "#{@command.inspect} is not a valid command"
+      assert_includes exp,         @kernel_spy.output
       assert_includes "Usage: qs", @kernel_spy.output
     end
 

data/test/unit/client_tests.rb

@@ -15,7 +15,7 @@ module Qs::Client
       ENV['QS_TEST_MODE'] = 'yes'
       Qs.init
 
-      @redis_config = Qs.redis_config
+      @redis_connect_hash = Qs.redis_connect_hash
       @queue        = Qs::Queue.new{ name Factory.string }
       @job_name     = Factory.string
       @job_params   = { Factory.string => Factory.string }
@@ -30,12 +30,12 @@ module Qs::Client
 
     should "return a qs client using `new`" do
       ENV.delete('QS_TEST_MODE')
-      client = subject.new(@redis_config)
+      client = subject.new(@redis_connect_hash)
       assert_instance_of Qs::QsClient, client
     end
 
     should "return a test client using `new` in test mode" do
-      client = subject.new(@redis_config)
+      client = subject.new(@redis_connect_hash)
       assert_instance_of Qs::TestClient, client
     end
 
@@ -43,11 +43,11 @@ module Qs::Client
 
   class MixinTests < UnitTests
     setup do
-      @client = FakeClient.new(@redis_config)
+      @client = FakeClient.new(@redis_connect_hash)
     end
     subject{ @client }
 
-    should have_readers :redis_config, :redis
+    should have_readers :redis_connect_hash, :redis
     should have_imeths :enqueue, :publish, :publish_as, :push
     should have_imeths :block_dequeue
     should have_imeths :append, :prepend
@@ -56,7 +56,7 @@ module Qs::Client
     should have_imeths :event_subscribers
 
     should "know its redis config" do
-      assert_equal @redis_config, subject.redis_config
+      assert_equal @redis_connect_hash, subject.redis_connect_hash
     end
 
     should "not have a redis connection" do
@@ -122,7 +122,7 @@ module Qs::Client
 
   class RedisCallTests < MixinTests
     setup do
-      @connection_spy = HellaRedis::ConnectionSpy.new(@client.redis_config)
+      @connection_spy = HellaRedis::ConnectionSpy.new(@client.redis_connect_hash)
       Assert.stub(@client, :redis){ @connection_spy }
 
       @queue_redis_key = Factory.string
@@ -284,13 +284,13 @@ module Qs::Client
         @connection_spy = HellaRedis::ConnectionSpy.new(*args)
       end
 
-      @client = @client_class.new(@redis_config)
+      @client = @client_class.new(@redis_connect_hash)
     end
     subject{ @client }
 
     should "build a redis connection" do
       assert_not_nil @connection_spy
-      assert_equal @connection_spy.config, subject.redis_config
+      assert_equal @connection_spy.config, subject.redis_connect_hash
       assert_equal @connection_spy, subject.redis
     end
 
@@ -338,7 +338,7 @@ module Qs::Client
       @serialized_job = nil
       Assert.stub(Qs::Payload, :serialize){ |job| @serialized_job = job }
 
-      @client = @client_class.new(@redis_config)
+      @client = @client_class.new(@redis_connect_hash)
     end
     subject{ @client }
 
@@ -347,7 +347,7 @@ module Qs::Client
 
     should "build a redis connection spy" do
       assert_instance_of HellaRedis::ConnectionSpy, subject.redis
-      assert_equal @redis_config, subject.redis.config
+      assert_equal @redis_connect_hash, subject.redis.config
     end
 
     should "default its pushed items" do

data/test/unit/config_file_tests.rb

@@ -15,7 +15,7 @@ class Qs::ConfigFile
     should have_imeths :run
 
     should "know its daemon" do
-      assert_instance_of AppDaemon, subject.daemon
+      assert_instance_of ConfigFileTestDaemon, subject.daemon
     end
 
     should "define constants in the file at the top-level binding" do
@@ -35,7 +35,7 @@ class Qs::ConfigFile
       assert_nothing_raised do
         config_file = Qs::ConfigFile.new(file_path)
       end
-      assert_instance_of AppDaemon, config_file.daemon
+      assert_instance_of ConfigFileTestDaemon, config_file.daemon
     end
 
     should "raise no config file error when the file doesn't exist" do

data/test/unit/daemon_data_tests.rb

@@ -13,23 +13,27 @@ class Qs::DaemonData
       ENV['QS_PROCESS_LABEL']    = Factory.string
 
       @current_env_debug = ENV['QS_DEBUG']
-      ENV['QS_DEBUG']    = Factory.string
+      ENV.delete('QS_DEBUG')
+
+      @queues = Factory.integer(3).times.map do
+        Qs::Queue.new{ name Factory.string }
+      end
 
-      @routes = (0..Factory.integer(3)).map do
+      @routes = Factory.integer(3).times.map do
         Qs::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
       end
 
       @config_hash = {
         :name             => Factory.string,
         :pid_file         => Factory.file_path,
+        :shutdown_timeout => Factory.integer,
         :worker_class     => Class.new,
         :worker_params    => { Factory.string => Factory.string },
         :num_workers      => Factory.integer,
+        :error_procs      => Factory.integer(3).times.map{ proc{} },
         :logger           => Factory.string,
+        :queues           => @queues,
         :verbose_logging  => Factory.boolean,
-        :shutdown_timeout => Factory.integer,
-        :error_procs      => [ proc{ Factory.string } ],
-        :queue_redis_keys => Factory.integer(3).times.map{ Factory.string },
         :routes           => @routes
       }
       @daemon_data = Qs::DaemonData.new(@config_hash)
@@ -40,31 +44,40 @@ class Qs::DaemonData
     end
     subject{ @daemon_data }
 
-    should have_readers :name, :process_label, :pid_file
+    should have_readers :name, :pid_file, :shutdown_timeout
     should have_readers :worker_class, :worker_params, :num_workers
-    should have_readers :debug, :logger, :dwp_logger, :verbose_logging
-    should have_readers :shutdown_timeout
-    should have_readers :error_procs, :queue_redis_keys, :routes
+    should have_readers :error_procs, :logger, :queue_redis_keys
+    should have_readers :verbose_logging
+    should have_readers :debug, :dwp_logger, :routes, :process_label
     should have_imeths :route_for
 
-    should "know its attributes" do
+    should "know its attrs" do
       h = @config_hash
-      assert_equal h[:name],             subject.name
-      assert_equal h[:pid_file],         subject.pid_file
-      assert_equal h[:worker_class],     subject.worker_class
-      assert_equal h[:worker_params],    subject.worker_params
-      assert_equal h[:num_workers],      subject.num_workers
-      assert_equal h[:logger],           subject.logger
-      assert_equal h[:verbose_logging],  subject.verbose_logging
+      assert_equal h[:name],     subject.name
+      assert_equal h[:pid_file], subject.pid_file
+
       assert_equal h[:shutdown_timeout], subject.shutdown_timeout
-      assert_equal h[:error_procs],      subject.error_procs
-      assert_equal h[:queue_redis_keys], subject.queue_redis_keys
+
+      assert_equal h[:worker_class],  subject.worker_class
+      assert_equal h[:worker_params], subject.worker_params
+      assert_equal h[:num_workers],   subject.num_workers
+      assert_equal h[:error_procs],   subject.error_procs
+      assert_equal h[:logger],        subject.logger
+
+      exp = @queues.map(&:redis_key)
+      assert_equal exp, subject.queue_redis_keys
+
+      assert_equal h[:verbose_logging], subject.verbose_logging
+
+      assert_false subject.debug
+      assert_nil   subject.dwp_logger
+
+      exp = @routes.inject({}){ |h, r| h.merge(r.id => r) }
+      assert_equal exp, subject.routes
     end
 
-    should "use process label env var if set" do
-      ENV['QS_PROCESS_LABEL'] = Factory.string
-      daemon_data = Qs::DaemonData.new(@config_hash)
-      assert_equal ENV['QS_PROCESS_LABEL'], daemon_data.process_label
+    should "know its process label" do
+      assert_equal ENV['QS_PROCESS_LABEL'], subject.process_label
 
       ENV['QS_PROCESS_LABEL'] = ""
       daemon_data = Qs::DaemonData.new(@config_hash)
@@ -75,32 +88,16 @@ class Qs::DaemonData
       assert_equal @config_hash[:name], daemon_data.process_label
     end
 
-    should "use debug env var if set" do
+    should "use the debug env var if set" do
       ENV['QS_DEBUG'] = Factory.string
       daemon_data = Qs::DaemonData.new(@config_hash)
       assert_true daemon_data.debug
-      assert_equal @config_hash[:logger], daemon_data.dwp_logger
-
-      ENV['QS_DEBUG'] = ""
-      daemon_data = Qs::DaemonData.new(@config_hash)
-      assert_false daemon_data.debug
-      assert_nil daemon_data.dwp_logger
-
-      ENV.delete('QS_DEBUG')
-      daemon_data = Qs::DaemonData.new(@config_hash)
-      assert_false daemon_data.debug
-      assert_nil daemon_data.dwp_logger
+      assert_equal daemon_data.logger, daemon_data.dwp_logger
     end
 
-    should "build a routes lookup hash" do
-      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
-      exp_route = @routes.choice
-      route = subject.route_for(exp_route.id)
-      assert_equal exp_route, route
+    should "look up a route using `route_for`" do
+      exp_route = @routes.sample
+      assert_equal exp_route, subject.route_for(exp_route.id)
     end
 
     should "raise a not found error using `route_for` with an invalid name" do
@@ -109,18 +106,26 @@ class Qs::DaemonData
       end
     end
 
-    should "default its attributes when they aren't provided" do
+    should "default its attrs when they aren't provided" do
       daemon_data = Qs::DaemonData.new
       assert_nil daemon_data.name
       assert_nil daemon_data.pid_file
+      assert_nil daemon_data.shutdown_timeout
+
       assert_nil daemon_data.worker_class
       assert_equal({}, daemon_data.worker_params)
       assert_nil daemon_data.num_workers
-      assert_nil daemon_data.logger
-      assert_false daemon_data.verbose_logging
-      assert_nil daemon_data.shutdown_timeout
+
       assert_equal [], daemon_data.error_procs
+
+      assert_nil daemon_data.logger
       assert_equal [], daemon_data.queue_redis_keys
+
+      assert_false daemon_data.verbose_logging
+
+      assert_false daemon_data.debug
+      assert_nil daemon_data.dwp_logger
+
       assert_equal({}, daemon_data.routes)
     end
 

data/test/unit/daemon_tests.rb

@@ -3,9 +3,9 @@ require 'qs/daemon'
 
 require 'dat-worker-pool/worker_pool_spy'
 require 'much-plugin'
-require 'ns-options/assert_macros'
 require 'thread'
 require 'qs/client'
+require 'qs/logger'
 require 'qs/queue'
 require 'qs/queue_item'
 require 'test/support/client_spy'
@@ -19,110 +19,80 @@ module Qs::Daemon
     end
     subject{ @daemon_class }
 
-    should have_imeths :configuration
-    should have_imeths :name, :pid_file
-    should have_imeths :worker_class, :worker_params
-    should have_imeths :num_workers, :workers
-    should have_imeths :verbose_logging, :logger
-    should have_imeths :shutdown_timeout
-    should have_imeths :init, :error, :queue, :queues
+    should have_imeths :config
+    should have_imeths :name, :pid_file, :shutdown_timeout
+    should have_imeths :worker_class, :worker_params, :num_workers, :workers
+    should have_imeths :init, :init_procs, :error, :error_procs
+    should have_imeths :logger, :queue, :queues
+    should have_imeths :verbose_logging
 
     should "use much-plugin" do
       assert_includes MuchPlugin, Qs::Daemon
     end
 
-    should "know its configuration" do
-      config = subject.configuration
-      assert_instance_of Configuration, config
-      assert_same config, subject.configuration
-    end
+    should "allow setting its config values" do
+      config = subject.config
 
-    should "allow reading/writing its configuration name" do
-      new_name = Factory.string
-      subject.name(new_name)
-      assert_equal new_name, subject.configuration.name
-      assert_equal new_name, subject.name
-    end
+      exp = Factory.string
+      subject.name exp
+      assert_equal exp, config.name
 
-    should "allow reading/writing its configuration pid file" do
-      new_pid_file = Factory.string
-      subject.pid_file(new_pid_file)
-      expected = Pathname.new(new_pid_file)
-      assert_equal expected, subject.configuration.pid_file
-      assert_equal expected, subject.pid_file
-    end
+      exp = Factory.file_path
+      subject.pid_file exp
+      assert_equal exp, config.pid_file
 
-    should "allow reading/writing its configuration worker class" do
-      new_worker_class = Class.new
-      subject.worker_class(new_worker_class)
-      assert_equal new_worker_class, subject.configuration.worker_class
-      assert_equal new_worker_class, subject.worker_class
-    end
+      exp = Factory.integer
+      subject.shutdown_timeout exp
+      assert_equal exp, config.shutdown_timeout
 
-    should "allow reading/writing its configuration worker params" do
-      new_worker_params = { Factory.string => Factory.string }
-      subject.worker_params(new_worker_params)
-      assert_equal new_worker_params, subject.configuration.worker_params
-      assert_equal new_worker_params, subject.worker_params
-    end
+      exp = Class.new
+      subject.worker_class exp
+      assert_equal exp, subject.config.worker_class
 
-    should "allow reading/writing its configuration num workers" do
-      new_num_workers = Factory.integer
-      subject.num_workers(new_num_workers)
-      assert_equal new_num_workers, subject.configuration.num_workers
-      assert_equal new_num_workers, subject.num_workers
-    end
+      exp = { Factory.string => Factory.string }
+      subject.worker_params exp
+      assert_equal exp, subject.config.worker_params
 
-    should "alias workers as num workers" do
-      new_workers = Factory.integer
-      subject.workers(new_workers)
-      assert_equal new_workers, subject.configuration.num_workers
-      assert_equal new_workers, subject.workers
-    end
+      exp = Factory.integer
+      subject.num_workers(exp)
+      assert_equal exp, subject.config.num_workers
+      assert_equal exp, subject.workers
 
-    should "allow reading/writing its configuration verbose logging" do
-      new_verbose = Factory.boolean
-      subject.verbose_logging(new_verbose)
-      assert_equal new_verbose, subject.configuration.verbose_logging
-      assert_equal new_verbose, subject.verbose_logging
-    end
+      exp = proc{ Factory.string }
+      assert_equal 0, config.init_procs.size
+      subject.init(&exp)
+      assert_equal 1, config.init_procs.size
+      assert_equal exp, config.init_procs.first
 
-    should "allow reading/writing its configuration logger" do
-      new_logger = Factory.string
-      subject.logger(new_logger)
-      assert_equal new_logger, subject.configuration.logger
-      assert_equal new_logger, subject.logger
-    end
+      exp = proc{ Factory.string }
+      assert_equal 0, config.error_procs.size
+      subject.error(&exp)
+      assert_equal 1, config.error_procs.size
+      assert_equal exp, config.error_procs.first
 
-    should "allow reading/writing its configuration shutdown timeout" do
-      new_shutdown_timeout = Factory.integer
-      subject.shutdown_timeout(new_shutdown_timeout)
-      assert_equal new_shutdown_timeout, subject.configuration.shutdown_timeout
-      assert_equal new_shutdown_timeout, subject.shutdown_timeout
-    end
+      exp = Logger.new(STDOUT)
+      subject.logger exp
+      assert_equal exp, config.logger
 
-    should "allow adding init procs to its configuration" do
-      new_init_proc = proc{ Factory.string }
-      subject.init(&new_init_proc)
-      assert_includes new_init_proc, subject.configuration.init_procs
-    end
+      exp = Factory.string
+      subject.queue(exp)
+      assert_equal [exp], subject.config.queues
 
-    should "allow adding error procs to its configuration" do
-      new_error_proc = proc{ Factory.string }
-      subject.error(&new_error_proc)
-      assert_includes new_error_proc, subject.configuration.error_procs
+      exp = Factory.boolean
+      subject.verbose_logging exp
+      assert_equal exp, config.verbose_logging
     end
 
-    should "allow adding queues to its configuration" do
-      new_queue = Factory.string
-      subject.queue(new_queue)
-      assert_includes new_queue, subject.configuration.queues
+    should "demeter its config values that aren't directly set" do
+      assert_equal subject.config.init_procs,  subject.init_procs
+      assert_equal subject.config.error_procs, subject.error_procs
     end
 
-    should "allow reading its configuration queues" do
-      new_queue = Factory.string
-      subject.queue(new_queue)
-      assert_equal [new_queue], subject.queues
+    should "know its queues" do
+      assert_equal [], subject.queues
+      exp = Factory.string
+      subject.queue(exp)
+      assert_equal [exp], subject.queues
     end
 
   end
@@ -134,10 +104,10 @@ module Qs::Daemon
 
       @daemon_class.name Factory.string
       @daemon_class.pid_file Factory.file_path
+      @daemon_class.shutdown_timeout Factory.integer
       @daemon_class.worker_params(Factory.string => Factory.string)
-      @daemon_class.workers Factory.integer
+      @daemon_class.num_workers Factory.integer
       @daemon_class.verbose_logging Factory.boolean
-      @daemon_class.shutdown_timeout Factory.integer
       @daemon_class.error{ Factory.string }
 
       @queue = Qs::Queue.new do
@@ -175,71 +145,65 @@ module Qs::Daemon
     end
     subject{ @daemon }
 
-    should have_readers :daemon_data, :logger
-    should have_readers :signals_redis_key, :queue_redis_keys
+    should have_readers :daemon_data, :signals_redis_key
     should have_imeths :name, :process_label, :pid_file
+    should have_imeths :logger, :queue_redis_keys
     should have_imeths :running?
     should have_imeths :start, :stop, :halt
 
-    should "validate its configuration" do
-      assert_true @daemon_class.configuration.valid?
+    should "have validated its config" do
+      assert_true @daemon_class.config.valid?
     end
 
-    should "init Qs" do
+    should "have initialized Qs" do
       assert_true @qs_init_called
     end
 
     should "know its daemon data" do
-      configuration = @daemon_class.configuration
-      data = subject.daemon_data
+      config = @daemon_class.config
+      data   = subject.daemon_data
 
       assert_instance_of Qs::DaemonData, data
-      assert_equal configuration.name,          data.name
-      assert_equal configuration.pid_file,      data.pid_file
-      assert_equal configuration.worker_class,  data.worker_class
-      assert_equal configuration.worker_params, data.worker_params
-      assert_equal configuration.num_workers,   data.num_workers
 
-      assert_equal configuration.verbose_logging,  data.verbose_logging
-      assert_equal configuration.shutdown_timeout, data.shutdown_timeout
-      assert_equal configuration.error_procs,      data.error_procs
+      assert_equal config.name,             data.name
+      assert_equal config.pid_file,         data.pid_file
+      assert_equal config.shutdown_timeout, data.shutdown_timeout
+      assert_equal config.worker_class,     data.worker_class
+      assert_equal config.worker_params,    data.worker_params
+      assert_equal config.num_workers,      data.num_workers
+      assert_equal config.error_procs,      data.error_procs
 
-      assert_equal [@queue.redis_key],   data.queue_redis_keys
-      assert_equal configuration.routes, data.routes.values
+      assert_instance_of config.logger.class, data.logger
 
-      assert_instance_of configuration.logger.class, data.logger
-    end
+      assert_equal config.queues.size,     data.queue_redis_keys.size
+      assert_equal config.verbose_logging, data.verbose_logging
 
-    should "know its signal and queues redis keys" do
-      data = subject.daemon_data
-      expected = "signals:#{data.name}-#{Socket.gethostname}-#{::Process.pid}"
-      assert_equal expected, subject.signals_redis_key
-      assert_equal data.queue_redis_keys, subject.queue_redis_keys
+      assert_equal config.routes, data.routes.values
     end
 
-    should "know its name, process label and pid file" do
+    should "know its signals redis keys" do
       data = subject.daemon_data
-      assert_equal data.name,          subject.name
-      assert_equal data.process_label, subject.process_label
-      assert_equal data.pid_file,      subject.pid_file
+      exp = "signals:#{data.name}-#{Socket.gethostname}-#{::Process.pid}"
+      assert_equal exp, subject.signals_redis_key
     end
 
     should "build a client" do
       assert_not_nil @client_spy
-      exp = Qs.redis_config.merge({
+      exp = Qs.redis_connect_hash.merge({
         :timeout => 1,
         :size    => subject.daemon_data.num_workers + 1
       })
-      assert_equal exp, @client_spy.redis_config
+      assert_equal exp, @client_spy.redis_connect_hash
     end
 
-    should "build a worker pool" do
+    should "build a dat-worker-pool worker pool" do
       data = subject.daemon_data
 
       assert_not_nil @wp_spy
       assert_equal data.worker_class, @wp_spy.worker_class
       assert_equal data.dwp_logger,   @wp_spy.logger
       assert_equal data.num_workers,  @wp_spy.num_workers
+
       exp = data.worker_params.merge({
         :qs_daemon_data      => data,
         :qs_client           => @client_spy,
@@ -250,6 +214,16 @@ module Qs::Daemon
       assert_false @wp_spy.start_called
     end
 
+    should "demeter its daemon data" do
+      data = subject.daemon_data
+
+      assert_equal data.name,             subject.name
+      assert_equal data.process_label,    subject.process_label
+      assert_equal data.pid_file,         subject.pid_file
+      assert_equal data.logger,           subject.logger
+      assert_equal data.queue_redis_keys, subject.queue_redis_keys
+    end
+
     should "not be running by default" do
       assert_false subject.running?
     end
@@ -260,7 +234,7 @@ module Qs::Daemon
     desc "and started"
     setup do
       @thread = @daemon.start
-      @thread.join 0.1
+      @thread.join(JOIN_SECONDS)
     end
 
     should "ping redis" do
@@ -296,14 +270,14 @@ module Qs::Daemon
 
       @daemon = @daemon_class.new
       @thread = @daemon.start
+      @thread.join(JOIN_SECONDS)
     end
     subject{ @daemon }
 
     should "sleep its thread and not add work to its worker pool" do
-      @thread.join(0.1)
       assert_equal 'sleep', @thread.status
       @client_spy.append(@queue.redis_key, Factory.string)
-      @thread.join(0.1)
+      @thread.join(JOIN_SECONDS)
       assert_empty @wp_spy.work_items
     end
 
@@ -314,17 +288,21 @@ module Qs::Daemon
     setup do
       @daemon = @daemon_class.new
       @thread = @daemon.start
+      @thread.join(JOIN_SECONDS)
 
       @encoded_payload = Factory.string
       @client_spy.append(@queue.redis_key, @encoded_payload)
+      @thread.join(JOIN_SECONDS)
     end
     subject{ @daemon }
 
     should "call dequeue on its client and add work to the worker pool" do
       call = @client_spy.calls.last
       assert_equal :block_dequeue, call.command
+
       exp = [subject.signals_redis_key, subject.queue_redis_keys, 0].flatten
       assert_equal exp, call.args
+
       exp = Qs::QueueItem.new(@queue.redis_key, @encoded_payload)
       assert_equal exp, @wp_spy.work_items.first
     end
@@ -334,25 +312,35 @@ module Qs::Daemon
   class RunningWithErrorWhileDequeuingTests < InitSetupTests
     desc "running with an error while dequeueing"
     setup do
-      @daemon = @daemon_class.new
-      @thread = @daemon.start
+      @mutex    = Mutex.new
+      @cond_var = ConditionVariable.new
+      @daemon   = @daemon_class.new
 
       @block_dequeue_calls = 0
       Assert.stub(@client_spy, :block_dequeue) do
         @block_dequeue_calls += 1
+        @mutex.synchronize{ @cond_var.wait(@mutex) }
         raise RuntimeError
       end
-      # cause the daemon to loop, its sleeping on the original block_dequeue
-      # call that happened before the stub
-      @client_spy.append(@queue.redis_key, Factory.string)
-      @thread.join(0.1)
+
+      @thread = @daemon.start
+      @thread.join(JOIN_SECONDS)
+    end
+    teardown do
+      Assert.unstub(@client_spy, :block_dequeue)
+      @mutex.synchronize{ @cond_var.broadcast }
     end
     subject{ @daemon }
 
     should "not cause the thread to exit" do
       assert_true @thread.alive?
       assert_equal 1, @block_dequeue_calls
-      @thread.join(1)
+
+      # the daemon is sleeping on the original block_dequeue, cause it to
+      # dequeue (and error)
+      @mutex.synchronize{ @cond_var.broadcast }
+      @thread.join(Qs::Daemon::FETCH_ERR_SLEEP_TIME + JOIN_SECONDS)
+
       assert_true @thread.alive?
       assert_equal 2, @block_dequeue_calls
     end
@@ -370,6 +358,7 @@ module Qs::Daemon
       Assert.stub(@daemon.queue_redis_keys, :shuffle){ @shuffled_keys }
 
       @thread = @daemon.start
+      @thread.join(JOIN_SECONDS)
     end
     subject{ @daemon }
 
@@ -419,6 +408,7 @@ module Qs::Daemon
       @wp_worker_available = false
       @daemon = @daemon_class.new
       @thread = @daemon.start
+      @thread.join(JOIN_SECONDS)
       @daemon.stop(true)
     end
     subject{ @daemon }
@@ -466,6 +456,7 @@ module Qs::Daemon
       @wp_worker_available = false
       @daemon = @daemon_class.new
       @thread = @daemon.start
+      @thread.join(JOIN_SECONDS)
       @daemon.halt(true)
     end
     subject{ @daemon }
@@ -486,7 +477,7 @@ module Qs::Daemon
       # call that happened before the stub
       @queue_item = Qs::QueueItem.new(@queue.redis_key, Factory.string)
       @client_spy.append(@queue_item.queue_redis_key, @queue_item.encoded_payload)
-      @thread.join
+      @thread.join(JOIN_SECONDS)
     end
 
     should "shutdown the worker pool" do
@@ -511,10 +502,8 @@ module Qs::Daemon
 
   end
 
-  class ConfigurationTests < UnitTests
-    include NsOptions::AssertMacros
-
-    desc "Configuration"
+  class ConfigTests < UnitTests
+    desc "Config"
     setup do
       @queue = Qs::Queue.new do
         name Factory.string
@@ -522,85 +511,106 @@ module Qs::Daemon
         job 'test', 'TestHandler'
       end
 
-      @configuration = Configuration.new.tap do |c|
-        c.name Factory.string
-        c.queues << @queue
-      end
+      @config_class = Config
+      @config = Config.new
     end
-    subject{ @configuration }
-
-    should have_options :name, :pid_file
-    should have_options :num_workers
-    should have_options :verbose_logging, :logger
-    should have_options :shutdown_timeout
-    should have_accessors :init_procs, :error_procs
-    should have_accessors :worker_class, :worker_params
-    should have_accessors :queues
-    should have_imeths :routes
-    should have_imeths :to_hash
-    should have_imeths :valid?, :validate!
-
-    should "be an ns-options proxy" do
-      assert_includes NsOptions::Proxy, subject.class
-    end
-
-    should "default its options and attrs" do
-      config = Configuration.new
-      assert_nil config.name
-      assert_nil config.pid_file
-      assert_equal 4, config.num_workers
-      assert_true config.verbose_logging
-      assert_instance_of Qs::NullLogger, config.logger
-      assert_nil subject.shutdown_timeout
+    subject{ @config }
 
-      assert_equal [], config.init_procs
-      assert_equal [], config.error_procs
-      assert_equal DefaultWorker, config.worker_class
-      assert_nil config.worker_params
-      assert_equal [], config.queues
-      assert_equal [], config.routes
+    should have_accessors :name, :pid_file, :shutdown_timeout
+    should have_accessors :worker_class, :worker_params, :num_workers
+    should have_accessors :init_procs, :error_procs, :logger, :queues
+    should have_accessors :verbose_logging
+    should have_imeths :routes, :valid?, :validate!
+
+    should "know its default attr values" do
+      assert_equal 4, @config_class::DEFAULT_NUM_WORKERS
     end
 
-    should "not be valid by default" do
-      assert_false subject.valid?
+    should "default its attrs" do
+      assert_nil subject.name
+      assert_nil subject.pid_file
+      assert_nil subject.shutdown_timeout
+
+      assert_equal DefaultWorker, subject.worker_class
+
+      assert_nil subject.worker_params
+
+      exp = @config_class::DEFAULT_NUM_WORKERS
+      assert_equal exp, subject.num_workers
+
+      assert_equal [], subject.init_procs
+      assert_equal [], subject.error_procs
+
+      assert_instance_of Qs::NullLogger, subject.logger
+
+      assert_equal [],   subject.queues
+      assert_equal true, subject.verbose_logging
     end
 
     should "know its routes" do
-      assert_equal subject.queues.map(&:routes).flatten, subject.routes
+      exp = subject.queues.map(&:routes).flatten
+      assert_equal exp, subject.routes
     end
 
-    should "include some attrs (not just the options) in its hash" do
-      config_hash = subject.to_hash
-
-      assert_equal subject.error_procs,   config_hash[:error_procs]
-      assert_equal subject.worker_class,  config_hash[:worker_class]
-      assert_equal subject.worker_params, config_hash[:worker_params]
-      assert_equal subject.routes,        config_hash[:routes]
+    should "not be valid until validate! has been run" do
+      assert_false subject.valid?
 
-      exp = subject.queues.map(&:redis_key)
-      assert_equal exp, config_hash[:queue_redis_keys]
-    end
+      subject.name = Factory.string
+      subject.queues << @queue
 
-    should "call its init procs when validated" do
-      called = false
-      subject.init_procs << proc{ called = true }
       subject.validate!
-      assert_true called
+      assert_true subject.valid?
     end
 
-    should "ensure its required options have been set when validated" do
+    should "complain if validating and its name is nil or it has no queues" do
       subject.name = nil
+      subject.queues << @queue
       assert_raises(InvalidError){ subject.validate! }
-      subject.name = Factory.string
 
-      subject.queues = []
+      subject.name = Factory.string
+      subject.queues.clear
       assert_raises(InvalidError){ subject.validate! }
+    end
+
+    should "complain if validating and its worker class isn't a Worker" do
+      subject.name = Factory.string
       subject.queues << @queue
 
-      assert_nothing_raised{ subject.validate! }
+      subject.worker_class = Module.new
+      assert_raises(InvalidError){ subject.validate! }
+
+      subject.worker_class = Class.new
+      assert_raises(InvalidError){ subject.validate! }
+    end
+
+  end
+
+  class ValidationTests < ConfigTests
+    desc "when successfully validated"
+    setup do
+      @config = Config.new.tap do |c|
+        c.name = Factory.string
+        c.queues << @queue
+      end
+
+      @initialized = false
+      @config.init_procs << proc{ @initialized = true }
+
+      @other_initialized = false
+      @config.init_procs << proc{ @other_initialized = true }
+    end
+
+    should "call its init procs" do
+      assert_equal false, @initialized
+      assert_equal false, @other_initialized
+
+      subject.validate!
+
+      assert_equal true, @initialized
+      assert_equal true, @other_initialized
     end
 
-    should "validate its routes when validated" do
+    should "validate its routes" do
       subject.routes.each{ |route| assert_nil route.handler_class }
       subject.validate!
       subject.routes.each{ |route| assert_not_nil route.handler_class }
@@ -614,12 +624,6 @@ module Qs::Daemon
       assert_raises(InvalidError){ subject.validate! }
     end
 
-    should "be valid after being validated" do
-      assert_false subject.valid?
-      subject.validate!
-      assert_true subject.valid?
-    end
-
     should "only be able to be validated once" do
       called = 0
       subject.init_procs << proc{ called += 1 }
@@ -631,6 +635,27 @@ module Qs::Daemon
 
   end
 
+  class WorkerAvailableTests < UnitTests
+    desc "WorkerAvailable"
+    setup do
+      @worker_available = WorkerAvailable.new
+    end
+    subject{ @worker_available }
+
+    should have_imeths :wait, :signal
+
+    should "allow waiting and signalling" do
+      thread = Thread.new{ subject.wait }
+      thread.join(JOIN_SECONDS)
+      assert_equal 'sleep', thread.status
+
+      subject.signal
+      thread.join(JOIN_SECONDS)
+      assert_equal false, thread.status # dead, done running
+    end
+
+  end
+
   class StateTests < UnitTests
     desc "State"
     setup do
@@ -664,24 +689,6 @@ module Qs::Daemon
 
   end
 
-  class WorkerAvailableTests < UnitTests
-    desc "WorkerAvailable"
-    setup do
-      @worker_available = WorkerAvailable.new
-    end
-    subject{ @worker_available }
-
-    should have_imeths :wait, :signal
-
-    should "allow waiting and signalling" do
-      thread = Thread.new{ subject.wait }
-      assert_equal 'sleep', thread.status
-      subject.signal
-      assert_equal false, thread.status # dead, done running
-    end
-
-  end
-
   TestHandler = Class.new
 
 end