qs 0.0.1 → 0.1.0

data/test/unit/daemon_tests.rb

@@ -0,0 +1,702 @@
+require 'assert'
+require 'qs/daemon'
+
+require 'dat-worker-pool/worker_pool_spy'
+require 'ns-options/assert_macros'
+require 'thread'
+require 'qs/client'
+require 'qs/queue'
+require 'qs/redis_item'
+
+module Qs::Daemon
+
+  class UnitTests < Assert::Context
+    desc "Qs::Daemon"
+    setup do
+      @daemon_class = Class.new{ include Qs::Daemon }
+    end
+    subject{ @daemon_class }
+
+    should have_imeths :configuration
+    should have_imeths :name, :pid_file
+    should have_imeths :min_workers, :max_workers, :workers
+    should have_imeths :verbose_logging, :logger
+    should have_imeths :shutdown_timeout
+    should have_imeths :init, :error, :queue
+
+    should "know its configuration" do
+      config = subject.configuration
+      assert_instance_of Configuration, config
+      assert_same config, subject.configuration
+    end
+
+    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
+
+    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
+
+    should "allow reading/writing its configuration min workers" do
+      new_min_workers = Factory.integer
+      subject.min_workers(new_min_workers)
+      assert_equal new_min_workers, subject.configuration.min_workers
+      assert_equal new_min_workers, subject.min_workers
+    end
+
+    should "allow reading/writing its configuration max workers" do
+      new_max_workers = Factory.integer
+      subject.max_workers(new_max_workers)
+      assert_equal new_max_workers, subject.configuration.max_workers
+      assert_equal new_max_workers, subject.max_workers
+    end
+
+    should "allow reading/writing its configuration workers" do
+      new_workers = Factory.integer
+      subject.workers(new_workers)
+      assert_equal new_workers, subject.configuration.min_workers
+      assert_equal new_workers, subject.configuration.max_workers
+      assert_equal new_workers, subject.min_workers
+      assert_equal new_workers, subject.max_workers
+    end
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+    end
+
+    should "allow adding queues to its configuration" do
+      new_queue = Factory.string
+      subject.queue(new_queue)
+      assert_includes new_queue, subject.configuration.queues
+    end
+
+  end
+
+  class InitSetupTests < UnitTests
+    setup do
+      @qs_init_called = false
+      Assert.stub(Qs, :init){ @qs_init_called = true }
+
+      @queue = Qs::Queue.new do
+        name(Factory.string)
+        job 'test', TestHandler.to_s
+      end
+      @daemon_class.name Factory.string
+      @daemon_class.pid_file Factory.file_path
+      @daemon_class.workers Factory.integer
+      @daemon_class.verbose_logging Factory.boolean
+      @daemon_class.shutdown_timeout Factory.integer
+      @daemon_class.error{ Factory.string }
+      @daemon_class.queue @queue
+
+      @client_spy = nil
+      Assert.stub(Qs::QsClient, :new) do |*args|
+        @client_spy = ClientSpy.new(*args)
+      end
+
+      @worker_pool_spy = nil
+      @worker_available = true
+      Assert.stub(::DatWorkerPool, :new) do |*args, &block|
+        @worker_pool_spy = DatWorkerPool::WorkerPoolSpy.new(*args, &block)
+        @worker_pool_spy.worker_available = !!@worker_available
+        @worker_pool_spy
+      end
+    end
+    teardown do
+      @daemon.halt(true) rescue false
+    end
+
+  end
+
+  class InitTests < InitSetupTests
+    desc "when init"
+    setup do
+      @daemon = @daemon_class.new
+    end
+    subject{ @daemon }
+
+    should have_readers :daemon_data, :logger
+    should have_readers :signals_redis_key, :queue_redis_keys
+    should have_imeths :name, :pid_file
+    should have_imeths :running?
+    should have_imeths :start, :stop, :halt
+
+    should "validate its configuration" do
+      assert_true @daemon_class.configuration.valid?
+    end
+
+    should "init Qs" do
+      assert_true @qs_init_called
+    end
+
+    should "know its daemon data" do
+      configuration = @daemon_class.configuration
+      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.min_workers,      data.min_workers
+      assert_equal configuration.max_workers,      data.max_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 [@queue.redis_key], data.queue_redis_keys
+      assert_equal configuration.routes, data.routes.values
+      assert_instance_of configuration.logger.class, data.logger
+    end
+
+    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
+    end
+
+    should "know its name and pid file" do
+      data = subject.daemon_data
+      assert_equal data.name,     subject.name
+      assert_equal data.pid_file, subject.pid_file
+    end
+
+    should "build a client" do
+      assert_not_nil @client_spy
+      exp = Qs.redis_config.merge({
+        :timeout => 1,
+        :size    => subject.daemon_data.max_workers + 1
+      })
+      assert_equal exp, @client_spy.redis_config
+    end
+
+    should "not be running by default" do
+      assert_false subject.running?
+    end
+
+  end
+
+  class StartTests < InitTests
+    desc "and started"
+    setup do
+      @thread = @daemon.start
+      @thread.join 0.1
+    end
+
+    should "return the thread that is running the daemon" do
+      assert_instance_of Thread, @thread
+      assert_true @thread.alive?
+    end
+
+    should "be running" do
+      assert_true subject.running?
+    end
+
+    should "clear the signals list in redis" do
+      call = @client_spy.calls.first
+      assert_equal :clear, call.command
+      assert_equal [subject.signals_redis_key], call.args
+    end
+
+    should "build and start a worker pool" do
+      assert_not_nil @worker_pool_spy
+      assert_equal @daemon_class.min_workers, @worker_pool_spy.min_workers
+      assert_equal @daemon_class.max_workers, @worker_pool_spy.max_workers
+      assert_equal 1, @worker_pool_spy.on_worker_error_callbacks.size
+      assert_equal 1, @worker_pool_spy.on_worker_sleep_callbacks.size
+      assert_true @worker_pool_spy.start_called
+    end
+
+  end
+
+  class RunningWithoutAvailableWorkerTests < InitSetupTests
+    desc "running without an available worker"
+    setup do
+      @worker_available = false
+
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+    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)
+      assert_empty @worker_pool_spy.work_items
+    end
+
+  end
+
+  class RunningWithWorkerAndWorkTests < InitSetupTests
+    desc "running with a worker available and work"
+    setup do
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+
+      @serialized_payload = Factory.string
+      @client_spy.append(@queue.redis_key, @serialized_payload)
+    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::RedisItem.new(@queue.redis_key, @serialized_payload)
+      assert_equal exp, @worker_pool_spy.work_items.first
+    end
+
+  end
+
+  class RunningWithMultipleQueuesTests < InitSetupTests
+    desc "running with multiple queues"
+    setup do
+      @other_queue = Qs::Queue.new{ name(Factory.string) }
+      @daemon_class.queue @other_queue
+      @daemon = @daemon_class.new
+
+      @shuffled_keys = @daemon.queue_redis_keys + [Factory.string]
+      Assert.stub(@daemon.queue_redis_keys, :shuffle){ @shuffled_keys }
+
+      @thread = @daemon.start
+    end
+    subject{ @daemon }
+
+    should "shuffle the queue keys to avoid queue starvation" do
+      call = @client_spy.calls.last
+      assert_equal :block_dequeue, call.command
+      exp = [subject.signals_redis_key, @shuffled_keys, 0].flatten
+      assert_equal exp, call.args
+    end
+
+  end
+
+  class WorkerPoolWorkProcTests < InitSetupTests
+    desc "worker pool work proc"
+    setup do
+      @ph_spy = nil
+      Assert.stub(Qs::PayloadHandler, :new) do |*args|
+        @ph_spy = PayloadHandlerSpy.new(*args)
+      end
+
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+
+      @redis_item = Qs::RedisItem.new(Factory.string, Factory.string)
+      @worker_pool_spy.work_proc.call(@redis_item)
+    end
+    subject{ @daemon }
+
+    should "build and run a payload handler" do
+      assert_not_nil @ph_spy
+      assert_equal subject.daemon_data, @ph_spy.daemon_data
+      assert_equal @redis_item,         @ph_spy.redis_item
+    end
+
+  end
+
+  class WorkerPoolOnWorkerErrorTests < InitSetupTests
+    desc "worker pool on worker error proc"
+    setup do
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+
+      @exception  = Factory.exception
+      @redis_item = Qs::RedisItem.new(Factory.string, Factory.string)
+      @callback   = @worker_pool_spy.on_worker_error_callbacks.first
+    end
+    subject{ @daemon }
+
+    should "requeue the redis item if it wasn't started" do
+      @redis_item.started = false
+      @callback.call('worker', @exception, @redis_item)
+      call = @client_spy.calls.detect{ |c| c.command == :prepend }
+      assert_not_nil call
+      assert_equal @redis_item.queue_redis_key,    call.args.first
+      assert_equal @redis_item.serialized_payload, call.args.last
+    end
+
+    should "not requeue the redis item if it was started" do
+      @redis_item.started = true
+      @callback.call('worker', @exception, @redis_item)
+      assert_nil @client_spy.calls.detect{ |c| c.command == :prepend }
+    end
+
+    should "do nothing if not passed a redis item" do
+      assert_nothing_raised{ @callback.call(@exception, nil) }
+    end
+
+  end
+
+  class StopTests < StartTests
+    desc "and then stopped"
+    setup do
+      @redis_item = Qs::RedisItem.new(@queue.redis_key, Factory.string)
+      @worker_pool_spy.add_work(@redis_item)
+
+      @daemon.stop true
+    end
+
+    should "shutdown the worker pool" do
+      assert_true @worker_pool_spy.shutdown_called
+      assert_equal @daemon_class.shutdown_timeout, @worker_pool_spy.shutdown_timeout
+    end
+
+    should "requeue any work left on the pool" do
+      call = @client_spy.calls.last
+      assert_equal :prepend, call.command
+      assert_equal @redis_item.queue_redis_key,    call.args.first
+      assert_equal @redis_item.serialized_payload, call.args.last
+    end
+
+    should "stop the work loop thread" do
+      assert_false @thread.alive?
+    end
+
+    should "not be running" do
+      assert_false subject.running?
+    end
+
+  end
+
+  class StopWhileWaitingForWorkerTests < InitSetupTests
+    desc "stopped while waiting for a worker"
+    setup do
+      @worker_available = false
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+      @daemon.stop(true)
+    end
+    subject{ @daemon }
+
+    should "not be running" do
+      assert_false subject.running?
+    end
+
+  end
+
+  class HaltTests < StartTests
+    desc "and then halted"
+    setup do
+      @redis_item = Qs::RedisItem.new(@queue.redis_key, Factory.string)
+      @worker_pool_spy.add_work(@redis_item)
+
+      @daemon.halt true
+    end
+
+    should "shutdown the worker pool with a 0 timeout" do
+      assert_true @worker_pool_spy.shutdown_called
+      assert_equal 0, @worker_pool_spy.shutdown_timeout
+    end
+
+    should "requeue any work left on the pool" do
+      call = @client_spy.calls.last
+      assert_equal :prepend, call.command
+      assert_equal @redis_item.queue_redis_key,    call.args.first
+      assert_equal @redis_item.serialized_payload, call.args.last
+    end
+
+    should "stop the work loop thread" do
+      assert_false @thread.alive?
+    end
+
+    should "not be running" do
+      assert_false subject.running?
+    end
+
+  end
+
+  class HaltWhileWaitingForWorkerTests < InitSetupTests
+    desc "halted while waiting for a worker"
+    setup do
+      @worker_available = false
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+      @daemon.halt(true)
+    end
+    subject{ @daemon }
+
+    should "not be running" do
+      assert_false subject.running?
+    end
+
+  end
+
+  class ConfigurationTests < UnitTests
+    include NsOptions::AssertMacros
+
+    desc "Configuration"
+    setup do
+      @queue = Qs::Queue.new do
+        name Factory.string
+        job_handler_ns 'Qs::Daemon'
+        job 'test', 'TestHandler'
+      end
+
+      @configuration = Configuration.new.tap do |c|
+        c.name Factory.string
+        c.queues << @queue
+      end
+    end
+    subject{ @configuration }
+
+    should have_options :name, :pid_file
+    should have_options :min_workers, :max_workers
+    should have_options :verbose_logging, :logger
+    should have_options :shutdown_timeout
+    should have_accessors :init_procs, :error_procs
+    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" do
+      config = Configuration.new
+      assert_nil config.name
+      assert_nil config.pid_file
+      assert_equal 1, config.min_workers
+      assert_equal 4, config.max_workers
+      assert_true config.verbose_logging
+      assert_instance_of Qs::NullLogger, config.logger
+      assert_nil subject.shutdown_timeout
+      assert_equal [], config.init_procs
+      assert_equal [], config.error_procs
+      assert_equal [], config.queues
+      assert_equal [], config.routes
+    end
+
+    should "not be valid by default" do
+      assert_false subject.valid?
+    end
+
+    should "know its routes" do
+      assert_equal subject.queues.map(&:routes).flatten, subject.routes
+    end
+
+    should "include its error procs, queue redis keys and routes in its hash" do
+      config_hash = subject.to_hash
+      assert_equal subject.error_procs, config_hash[:error_procs]
+      expected = subject.queues.map(&:redis_key)
+      assert_equal expected, config_hash[:queue_redis_keys]
+      assert_equal subject.routes, config_hash[:routes]
+    end
+
+    should "call its init procs when validated" do
+      called = false
+      subject.init_procs << proc{ called = true }
+      subject.validate!
+      assert_true called
+    end
+
+    should "ensure its required options have been set when validated" do
+      subject.name = nil
+      assert_raises(InvalidError){ subject.validate! }
+      subject.name = Factory.string
+
+      subject.queues = []
+      assert_raises(InvalidError){ subject.validate! }
+      subject.queues << @queue
+
+      assert_nothing_raised{ subject.validate! }
+    end
+
+    should "validate its routes when validated" do
+      subject.routes.each{ |route| assert_nil route.handler_class }
+      subject.validate!
+      subject.routes.each{ |route| assert_not_nil route.handler_class }
+    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 }
+      subject.validate!
+      assert_equal 1, called
+      subject.validate!
+      assert_equal 1, called
+    end
+
+  end
+
+  class IOPipeTests < UnitTests
+    desc "IOPipe"
+    setup do
+      @io = IOPipe.new
+    end
+    subject{ @io }
+
+    should have_readers :reader, :writer
+    should have_imeths :wait, :signal
+    should have_imeths :setup, :teardown
+
+    should "default its reader and writer" do
+      assert_same IOPipe::NULL, subject.reader
+      assert_same IOPipe::NULL, subject.writer
+    end
+
+    should "be able to wait until signalled" do
+      subject.setup
+
+      thread = Thread.new{ subject.wait }
+      thread.join(0.1)
+      assert_equal 'sleep', thread.status
+
+      subject.signal
+      thread.join
+      assert_false thread.status
+    end
+
+    should "set its reader and writer to an IO pipe when setup" do
+      subject.setup
+      assert_instance_of ::IO, subject.reader
+      assert_instance_of ::IO, subject.writer
+    end
+
+    should "close its reader/writer and set them to defaults when torn down" do
+      subject.setup
+      reader = subject.reader
+      writer = subject.writer
+
+      subject.teardown
+      assert_true reader.closed?
+      assert_true writer.closed?
+      assert_same IOPipe::NULL, subject.reader
+      assert_same IOPipe::NULL, subject.writer
+    end
+
+  end
+
+  class SignalTests < UnitTests
+    desc "Signal"
+    setup do
+      @signal = Signal.new(:stop)
+    end
+    subject{ @signal }
+
+    should have_imeths :set, :start?, :stop?, :halt?
+
+    should "allow setting it to start" do
+      subject.set :start
+      assert_true subject.start?
+      assert_false subject.stop?
+      assert_false subject.halt?
+    end
+
+    should "allow setting it to stop" do
+      subject.set :stop
+      assert_false subject.start?
+      assert_true subject.stop?
+      assert_false subject.halt?
+    end
+
+    should "allow setting it to halt" do
+      subject.set :halt
+      assert_false subject.start?
+      assert_false subject.stop?
+      assert_true subject.halt?
+    end
+
+  end
+
+  TestHandler = Class.new
+
+  class PayloadHandlerSpy
+    attr_reader :daemon_data, :redis_item, :run_called
+
+    def initialize(daemon_data, redis_item)
+      @daemon_data = daemon_data
+      @redis_item  = redis_item
+      @run_called  = false
+    end
+
+    def run
+      @run_called = true
+    end
+  end
+
+  class ClientSpy < Qs::TestClient
+    attr_reader :calls
+
+    def initialize(*args)
+      super
+      @calls = []
+      @list  = []
+      @mutex = Mutex.new
+      @cv    = ConditionVariable.new
+    end
+
+    def block_dequeue(*args)
+      @calls << Call.new(:block_dequeue, args)
+      if @list.empty?
+        @mutex.synchronize{ @cv.wait(@mutex) }
+      end
+      @list.shift
+    end
+
+    def append(*args)
+      @calls << Call.new(:append, args)
+      @list  << args
+      @cv.signal
+    end
+
+    def prepend(*args)
+      @calls << Call.new(:prepend, args)
+      @list  << args
+      @cv.signal
+    end
+
+    def clear(*args)
+      @calls << Call.new(:clear, args)
+    end
+
+    Call = Struct.new(:command, :args)
+  end
+
+end