qs 0.0.1 → 0.1.0

data/test/unit/client_tests.rb

@@ -0,0 +1,269 @@
+require 'assert'
+require 'qs/client'
+
+require 'hella-redis/connection_spy'
+require 'qs'
+require 'qs/job'
+require 'qs/queue'
+
+module Qs::Client
+
+  class UnitTests < Assert::Context
+    desc "Qs::Client"
+    setup do
+      @current_test_mode = ENV['QS_TEST_MODE']
+      ENV['QS_TEST_MODE'] = 'yes'
+      Qs.init
+
+      @redis_config = Qs.redis_config
+      @queue        = Qs::Queue.new{ name Factory.string }
+      @job_name     = Factory.string
+      @job_params   = { Factory.string => Factory.string }
+    end
+    teardown do
+      Qs.reset!
+      ENV['QS_TEST_MODE'] = @current_test_mode
+    end
+    subject{ Qs::Client }
+
+    should have_imeths :new
+
+    should "return a qs client using `new`" do
+      ENV.delete('QS_TEST_MODE')
+      client = subject.new(@redis_config)
+      assert_instance_of Qs::QsClient, client
+    end
+
+    should "return a test client using `new` in test mode" do
+      client = subject.new(@redis_config)
+      assert_instance_of Qs::TestClient, client
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    setup do
+      @client = FakeClient.new(@redis_config)
+    end
+    subject{ @client }
+
+    should have_readers :redis_config, :redis
+    should have_imeths :enqueue, :push
+    should have_imeths :block_dequeue
+    should have_imeths :append, :prepend
+    should have_imeths :clear
+
+    should "know its redis config" do
+      assert_equal @redis_config, subject.redis_config
+    end
+
+    should "not have a redis connection" do
+      assert_nil subject.redis
+    end
+
+    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)
+    end
+
+    should "raise a not implemented error using `push`" do
+      assert_raises(NotImplementedError) do
+        subject.push(Factory.string, Factory.string)
+      end
+    end
+
+  end
+
+  class RedisCallTests < MixinTests
+    setup do
+      @connection_spy = HellaRedis::ConnectionSpy.new(@client.redis_config)
+      Assert.stub(@client, :redis){ @connection_spy }
+
+      @queue_redis_key    = Factory.string
+      @serialized_payload = Factory.string
+    end
+
+    should "block pop from the front of a list using `block_dequeue`" do
+      args = (1..Factory.integer(3)).map{ Factory.string } + [Factory.integer]
+      subject.block_dequeue(*args)
+
+      call = @connection_spy.redis_calls.last
+      assert_equal :brpop, call.command
+      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)
+
+      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
+    end
+
+    should "add a serialized payload to the front of a list using `prepend`" do
+      subject.prepend(@queue_redis_key, @serialized_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
+    end
+
+    should "del a list using `clear`" do
+      subject.clear(@queue_redis_key)
+
+      call = @connection_spy.redis_calls.last
+      assert_equal :del,               call.command
+      assert_equal [@queue_redis_key], call.args
+    end
+
+  end
+
+  class QsClientTests < UnitTests
+    desc "QsClient"
+    setup do
+      @client_class = Qs::QsClient
+    end
+    subject{ @client_class }
+
+    should "be a qs client" do
+      assert_includes Qs::Client, subject
+    end
+
+  end
+
+  class QsClientInitTests < QsClientTests
+    desc "when init"
+    setup do
+      @connection_spy = nil
+      Assert.stub(HellaRedis::Connection, :new) do |*args|
+        @connection_spy = HellaRedis::ConnectionSpy.new(*args)
+      end
+
+      @client = @client_class.new(@redis_config)
+    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, subject.redis
+    end
+
+    should "add jobs to the queue's 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']
+    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)
+
+      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
+    end
+
+  end
+
+  class TestClientTests < UnitTests
+    desc "TestClient"
+    setup do
+      @client_class = Qs::TestClient
+    end
+    subject{ @client_class }
+
+    should "be a qs client" do
+      assert_includes Qs::Client, subject
+    end
+
+  end
+
+  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)
+
+      @client = @client_class.new(@redis_config)
+    end
+    subject{ @client }
+
+    should have_readers :pushed_items
+    should have_imeths :reset!
+
+    should "build a redis connection spy" do
+      assert_instance_of HellaRedis::ConnectionSpy, subject.redis
+      assert_equal @redis_config, subject.redis.config
+    end
+
+    should "default its pushed items" do
+      assert_equal [], subject.pushed_items
+    end
+
+    should "track all the jobs it enqueues on the queue" do
+      assert_empty @queue.enqueued_jobs
+      result = subject.enqueue(@queue, @job_name, @job_params)
+
+      job = @queue.enqueued_jobs.last
+      assert_equal @job_name,   job.name
+      assert_equal @job_params, job.params
+      assert_equal job, result
+    end
+
+    should "serialize the jobs when enqueueing" do
+      subject.enqueue(@queue, @job_name, @job_params)
+
+      job = @queue.enqueued_jobs.last
+      assert_equal job.to_payload, @serialized_payload
+    end
+
+    should "track all the payloads pushed onto a queue" do
+      subject.push(@queue.name, @job.to_payload)
+
+      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
+    end
+
+    should "clear its pushed items when reset" do
+      subject.push(@queue.name, @job.to_payload)
+      assert_not_empty subject.pushed_items
+      subject.reset!
+      assert_empty subject.pushed_items
+    end
+
+  end
+
+  class FakeClient
+    include Qs::Client
+
+    attr_reader :enqueued_jobs
+
+    def enqueue!(queue, job)
+      @enqueued_jobs ||= []
+      @enqueued_jobs << job
+    end
+  end
+
+end

data/test/unit/config_file_tests.rb

@@ -0,0 +1,59 @@
+require 'assert'
+require 'qs/config_file'
+
+class Qs::ConfigFile
+
+  class UnitTests < Assert::Context
+    desc "Qs::ConfigFile"
+    setup do
+      @file_path = ROOT_PATH.join('test/support/config.qs')
+      @config_file = Qs::ConfigFile.new(@file_path)
+    end
+    subject{ @config_file }
+
+    should have_readers :daemon
+    should have_imeths :run
+
+    should "know its daemon" do
+      assert_instance_of AppDaemon, subject.daemon
+    end
+
+    should "define constants in the file at the top-level binding" do
+      assert_not_nil defined?(::TestConstant)
+    end
+
+    should "set its daemon using run" do
+      fake_daemon = Factory.string
+      subject.run fake_daemon
+      assert_equal fake_daemon, subject.daemon
+    end
+
+    should "allow passing a path without the extension" do
+      file_path = ROOT_PATH.join('test/support/config')
+      config_file = nil
+
+      assert_nothing_raised do
+        config_file = Qs::ConfigFile.new(file_path)
+      end
+      assert_instance_of AppDaemon, config_file.daemon
+    end
+
+    should "raise no config file error when the file doesn't exist" do
+      assert_raises(NoConfigFileError) do
+        Qs::ConfigFile.new(Factory.file_path)
+      end
+    end
+
+    should "raise a no daemon error when the file doesn't call run" do
+      file_path = ROOT_PATH.join('test/support/config_no_run.qs')
+      assert_raises(NoDaemonError){ Qs::ConfigFile.new(file_path) }
+    end
+
+    should "raise a no daemon error when the file provides an invalid daemon" do
+      file_path = ROOT_PATH.join('test/support/config_invalid_run.qs')
+      assert_raises(NoDaemonError){ Qs::ConfigFile.new(file_path) }
+    end
+
+  end
+
+end

data/test/unit/daemon_data_tests.rb

@@ -0,0 +1,96 @@
+require 'assert'
+require 'qs/daemon_data'
+
+require 'qs/queue'
+require 'qs/route'
+
+class Qs::DaemonData
+
+  class UnitTests < Assert::Context
+    desc "Qs::DaemonData"
+    setup do
+      @name = Factory.string
+      @pid_file = Factory.file_path
+      @min_workers = Factory.integer
+      @max_workers = Factory.integer
+      @logger = Factory.string
+      @verbose_logging = Factory.boolean
+      @shutdown_timeout = Factory.integer
+      @error_procs = [ proc{ Factory.string } ]
+      @queue_redis_keys = (0..Factory.integer(3)).map{ Factory.string }
+      @routes = (0..Factory.integer(3)).map do
+        Qs::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
+      end
+
+      @daemon_data = Qs::DaemonData.new({
+        :name             => @name,
+        :pid_file         => @pid_file,
+        :min_workers      => @min_workers,
+        :max_workers      => @max_workers,
+        :logger           => @logger,
+        :verbose_logging  => @verbose_logging,
+        :shutdown_timeout => @shutdown_timeout,
+        :error_procs      => @error_procs,
+        :queue_redis_keys => @queue_redis_keys,
+        :routes           => @routes
+      })
+    end
+    subject{ @daemon_data }
+
+    should have_readers :name
+    should have_readers :pid_file
+    should have_readers :min_workers, :max_workers
+    should have_readers :logger, :verbose_logging
+    should have_readers :shutdown_timeout
+    should have_readers :error_procs
+    should have_readers :queue_redis_keys, :routes
+    should have_imeths :route_for
+
+    should "know its attributes" do
+      assert_equal @name,             subject.name
+      assert_equal @pid_file,         subject.pid_file
+      assert_equal @min_workers,      subject.min_workers
+      assert_equal @max_workers,      subject.max_workers
+      assert_equal @logger,           subject.logger
+      assert_equal @verbose_logging,  subject.verbose_logging
+      assert_equal @shutdown_timeout, subject.shutdown_timeout
+      assert_equal @error_procs,      subject.error_procs
+      assert_equal @queue_redis_keys, subject.queue_redis_keys
+    end
+
+    should "build a routes lookup hash" do
+      expected = @routes.inject({}){ |h, r| h.merge(r.name => r) }
+      assert_equal expected, subject.routes
+    end
+
+    should "allow looking up a route using `route_for`" do
+      expected = @routes.choice
+      route = subject.route_for(expected.name)
+      assert_equal expected, route
+    end
+
+    should "raise a not found error using `route_for` with an invalid name" do
+      assert_raises(Qs::NotFoundError) do
+        subject.route_for(Factory.string)
+      end
+    end
+
+    should "default its attributes 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.min_workers
+      assert_nil daemon_data.max_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_equal [], daemon_data.queue_redis_keys
+      assert_equal({}, daemon_data.routes)
+    end
+
+  end
+
+  TestHandler = Class.new
+
+end