qs 0.0.1 → 0.1.0

data/test/unit/qs_tests.rb

@@ -0,0 +1,217 @@
+require 'assert'
+require 'qs'
+
+require 'hella-redis/connection_spy'
+require 'ns-options/assert_macros'
+require 'qs/job'
+require 'qs/queue'
+
+module Qs
+
+  class UnitTests < Assert::Context
+    desc "Qs"
+    setup do
+      Qs.reset!
+      @module = Qs
+    end
+    teardown do
+      Qs.reset!
+      Qs.init
+    end
+    subject{ @module }
+
+    should have_imeths :config, :configure, :init, :reset!
+    should have_imeths :enqueue, :push
+    should have_imeths :serialize, :deserialize
+    should have_imeths :client, :redis, :redis_config
+
+    should "know its config" do
+      assert_instance_of Config, subject.config
+    end
+
+    should "allow configuring its config" do
+      yielded = nil
+      subject.configure{ |c| yielded = c }
+      assert_equal subject.config, yielded
+    end
+
+    should "not have a client or redis connection by default" do
+      assert_nil subject.client
+      assert_nil subject.redis
+    end
+
+    should "know its redis config" do
+      expected = subject.config.redis.to_hash
+      assert_equal expected, subject.redis_config
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @module.config.serializer   = proc{ |v| v.to_s }
+      @module.config.deserializer = proc{ |v| v.to_i }
+      @module.config.redis.ip     = Factory.string
+      @module.config.redis.port   = Factory.integer
+      @module.config.redis.db     = Factory.integer
+
+      @client_spy = nil
+      Assert.stub(Client, :new) do |*args|
+        @client_spy = ClientSpy.new(*args)
+      end
+
+      @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
+    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
+    end
+
+    should "call enqueue on its client using `enqueue`" do
+      queue      = Qs::Queue.new{ name Factory.string }
+      job_name   = Factory.string
+      job_params = { Factory.string => Factory.string }
+      subject.enqueue(queue, job_name, job_params)
+
+      call = @client_spy.enqueue_calls.last
+      assert_equal queue,      call.queue
+      assert_equal job_name,   call.job_name
+      assert_equal job_params, call.job_params
+    end
+
+    should "call push on its client using `push`" do
+      queue_name = Factory.string
+      payload    = { Factory.string => Factory.string }
+      subject.push(queue_name, payload)
+
+      call = @client_spy.push_calls.last
+      assert_equal queue_name, call.queue_name
+      assert_equal payload,    call.payload
+    end
+
+    should "use the configured serializer using `serialize`" do
+      value = Factory.integer
+      result = subject.serialize(value)
+      assert_equal value.to_s, result
+    end
+
+    should "use the configured deserializer using `deserialize`" do
+      value = Factory.integer.to_s
+      result = subject.deserialize(value)
+      assert_equal value.to_i, result
+    end
+
+    should "not reset its client or redis connection when init again" do
+      client = subject.client
+      redis  = subject.redis
+      subject.init
+      assert_same client, subject.client
+      assert_same redis,  subject.redis
+    end
+
+    should "reset itself using `reset!`" do
+      subject.reset!
+      assert_nil subject.config.redis.url
+      assert_nil subject.client
+      assert_nil subject.redis
+      assert_raises(NoMethodError){ subject.serialize(Factory.integer) }
+      assert_raises(NoMethodError){ subject.deserialize(Factory.integer) }
+    end
+
+  end
+
+  class ConfigTests < UnitTests
+    include NsOptions::AssertMacros
+
+    desc "Config"
+    setup do
+      @config = Config.new
+    end
+    subject{ @config }
+
+    should have_options :serializer, :deserializer, :timeout
+    should have_namespace :redis
+
+    should "know its default serializer/deserializer" do
+      payload = { Factory.string => Factory.string }
+
+      exp = JSON.dump(payload)
+      serialized_payload = subject.serializer.call(payload)
+      assert_equal exp, serialized_payload
+      exp = JSON.load(exp)
+      assert_equal exp, subject.deserializer.call(serialized_payload)
+    end
+
+    should "know its default timeout" do
+      assert_nil subject.timeout
+    end
+
+    should "know its default redis options" do
+      assert_equal 'localhost', 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
+    end
+
+  end
+
+  class RedisUrlTests < UnitTests
+    desc "RedisUrl"
+    subject{ RedisUrl }
+
+    should "build a redis url when passed an ip, port and db" do
+      ip   = Factory.string
+      port = Factory.integer
+      db   = Factory.integer
+      expected = "redis://#{ip}:#{port}/#{db}"
+      assert_equal expected, subject.new(ip, port, db)
+    end
+
+    should "not return a url with an ip, port or db" do
+      assert_nil subject.new(nil, Factory.integer, Factory.integer)
+      assert_nil subject.new(Factory.string, nil, Factory.integer)
+      assert_nil subject.new(Factory.string, Factory.integer, nil)
+    end
+
+  end
+
+  class ClientSpy
+    attr_reader :redis_config, :redis
+    attr_reader :enqueue_calls, :push_calls
+
+    def initialize(redis_confg)
+      @redis_config  = redis_confg
+      @redis         = Factory.string
+      @enqueue_calls = []
+      @push_calls    = []
+    end
+
+    def enqueue(queue, job_name, job_params = nil)
+      @enqueue_calls << EnqueueCall.new(queue, job_name, job_params)
+    end
+
+    def push(queue_name, payload)
+      @push_calls << PushCall.new(queue_name, payload)
+    end
+
+    EnqueueCall = Struct.new(:queue, :job_name, :job_params)
+    PushCall    = Struct.new(:queue_name, :payload)
+  end
+
+end

data/test/unit/queue_tests.rb

@@ -0,0 +1,132 @@
+require 'assert'
+require 'qs/queue'
+
+require 'test/support/factory'
+
+class Qs::Queue
+
+  class UnitTests < Assert::Context
+    desc "Qs::Queue"
+    setup do
+      @queue = Qs::Queue.new do
+        name Factory.string
+      end
+    end
+    subject{ @queue }
+
+    should have_readers :routes, :enqueued_jobs
+    should have_imeths :name, :redis_key, :job_handler_ns, :job
+    should have_imeths :enqueue, :add
+    should have_imeths :reset!
+
+    should "default its routes to an empty array" do
+      assert_equal [], subject.routes
+    end
+
+    should "default its enqueued jobs to an empty array" do
+      assert_equal [], subject.enqueued_jobs
+    end
+
+    should "allow setting its name" do
+      name = Factory.string
+      subject.name name
+      assert_equal name, subject.name
+    end
+
+    should "know its redis key" do
+      result = subject.redis_key
+      assert_equal RedisKey.new(subject.name), result
+      assert_same result, subject.redis_key
+    end
+
+    should "not have a job handler ns by default" do
+      assert_nil subject.job_handler_ns
+    end
+
+    should "allow setting its job handler ns" do
+      namespace = Factory.string
+      subject.job_handler_ns namespace
+      assert_equal namespace, subject.job_handler_ns
+    end
+
+    should "allow adding routes using `job`" do
+      job_name = Factory.string
+      handler_name = Factory.string
+      subject.job job_name, handler_name
+
+      route = subject.routes.last
+      assert_instance_of Qs::Route, route
+      assert_equal job_name, route.name
+      assert_equal handler_name, route.handler_class_name
+    end
+
+    should "use its job handler ns when adding routes" do
+      namespace = Factory.string
+      subject.job_handler_ns namespace
+
+      job_name = Factory.string
+      handler_name = Factory.string
+      subject.job job_name, handler_name
+
+      route = subject.routes.last
+      expected = "#{namespace}::#{handler_name}"
+      assert_equal expected, route.handler_class_name
+    end
+
+    should "know its custom inspect" do
+      reference = '0x0%x' % (subject.object_id << 1)
+      expected = "#<#{subject.class}:#{reference} " \
+                   "@name=#{subject.name.inspect} " \
+                   "@job_handler_ns=#{subject.job_handler_ns.inspect}>"
+      assert_equal expected, subject.inspect
+    end
+
+    should "require a name when initialized" do
+      assert_raises(InvalidError){ Qs::Queue.new }
+    end
+
+  end
+
+  class EnqueueTests < UnitTests
+    setup do
+      @enqueue_args = nil
+      Assert.stub(Qs, :enqueue){ |*args| @enqueue_args = args }
+
+      @job_name   = Factory.string
+      @job_params = { Factory.string => Factory.string }
+    end
+
+    should "add jobs using `enqueue`" do
+      result = subject.enqueue(@job_name, @job_params)
+      exp = [subject, @job_name, @job_params]
+      assert_equal exp, @enqueue_args
+      assert_equal @enqueue_args, result
+    end
+
+    should "add jobs using `add`" do
+      result = subject.add(@job_name, @job_params)
+      exp = [subject, @job_name, @job_params]
+      assert_equal exp, @enqueue_args
+      assert_equal @enqueue_args, result
+    end
+
+  end
+
+  class RedisKeyTests < UnitTests
+    desc "RedisKey"
+    subject{ RedisKey }
+
+    should have_imeths :parse_name, :new
+
+    should "know how to build a redis key" do
+      assert_equal "queues:#{@queue.name}", subject.new(@queue.name)
+    end
+
+    should "know how to parse a queue name from a key" do
+      redis_key = subject.new(@queue.name)
+      assert_equal @queue.name, subject.parse_name(redis_key)
+    end
+
+  end
+
+end

data/test/unit/redis_item_tests.rb

@@ -0,0 +1,49 @@
+require 'assert'
+require 'qs/redis_item'
+
+class Qs::RedisItem
+
+  class UnitTests < Assert::Context
+    desc "Qs::RedisItem"
+    setup do
+      @queue_redis_key    = Factory.string
+      @serialized_payload = Factory.string
+      @redis_item = Qs::RedisItem.new(@queue_redis_key, @serialized_payload)
+    end
+    subject{ @redis_item }
+
+    should have_readers :queue_redis_key, :serialized_payload
+    should have_accessors :started, :finished
+    should have_accessors :job, :handler_class
+    should have_accessors :exception, :time_taken
+
+    should "know its queue redis key and serialized payload" do
+      assert_equal @queue_redis_key,    subject.queue_redis_key
+      assert_equal @serialized_payload, subject.serialized_payload
+    end
+
+    should "defaults its other attributes" do
+      assert_false subject.started
+      assert_false subject.finished
+
+      assert_nil subject.job
+      assert_nil subject.handler_class
+      assert_nil subject.exception
+      assert_nil subject.time_taken
+    end
+
+    should "know if it equals another item" do
+      exp = Qs::RedisItem.new(@queue_redis_key, @serialized_payload)
+      assert_equal exp, subject
+
+      redis_key = Qs::Queue::RedisKey.new(Factory.string)
+      exp = Qs::RedisItem.new(redis_key, @serialized_payload)
+      assert_not_equal exp, subject
+
+      exp = Qs::RedisItem.new(@queue_redis_key, Factory.string)
+      assert_not_equal exp, subject
+    end
+
+  end
+
+end

data/test/unit/route_tests.rb

@@ -0,0 +1,81 @@
+require 'assert'
+require 'qs/route'
+
+require 'qs/daemon_data'
+require 'qs/logger'
+require 'qs/job'
+require 'test/support/runner_spy'
+
+class Qs::Route
+
+  class UnitTests < Assert::Context
+    desc "Qs::Route"
+    setup do
+      @name = Factory.string
+      @handler_class_name = TestHandler.to_s
+      @route = Qs::Route.new(@name, @handler_class_name)
+    end
+    subject{ @route }
+
+    should have_readers :name, :handler_class_name, :handler_class
+    should have_imeths :validate!, :run
+
+    should "know its name and handler class name" do
+      assert_equal @name, subject.name
+      assert_equal @handler_class_name, subject.handler_class_name
+    end
+
+    should "not know its handler class by default" do
+      assert_nil subject.handler_class
+    end
+
+    should "constantize its handler class after being validated" do
+      subject.validate!
+      assert_equal TestHandler, subject.handler_class
+    end
+
+  end
+
+  class RunTests < UnitTests
+    desc "when run"
+    setup do
+      @job = Qs::Job.new(Factory.string, Factory.string => Factory.string)
+      @daemon_data = Qs::DaemonData.new(:logger => Qs::NullLogger.new)
+
+      @runner_spy = nil
+      Assert.stub(Qs::QsRunner, :new) do |*args|
+        @runner_spy = RunnerSpy.new(*args)
+      end
+
+      @route.run(@job, @daemon_data)
+    end
+
+    should "build and run a qs runner" do
+      assert_not_nil @runner_spy
+      assert_equal @route.handler_class, @runner_spy.handler_class
+      expected = {
+        :job    => @job,
+        :params => @job.params,
+        :logger => @daemon_data.logger
+      }
+      assert_equal expected, @runner_spy.args
+      assert_true @runner_spy.run_called
+    end
+
+  end
+
+  class InvalidHandlerClassNameTests < UnitTests
+    desc "with an invalid handler class name"
+    setup do
+      @route = Qs::Route.new(@name, Factory.string)
+    end
+
+    should "raise a no handler class error when validated" do
+      assert_raises(Qs::NoHandlerClassError){ subject.validate! }
+    end
+
+  end
+
+  TestHandler = Class.new
+
+end

data/test/unit/runner_tests.rb

@@ -0,0 +1,63 @@
+require 'assert'
+require 'qs/runner'
+
+require 'qs/job_handler'
+require 'qs/logger'
+
+class Qs::Runner
+
+  class UnitTests < Assert::Context
+    desc "Qs::Runner"
+    setup do
+      @runner_class = Qs::Runner
+    end
+    subject{ @runner_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @handler_class = TestJobHandler
+      @runner = @runner_class.new(@handler_class)
+    end
+    subject{ @runner }
+
+    should have_readers :handler_class, :handler
+    should have_readers :job, :params, :logger
+    should have_imeths :run
+
+    should "know its handler class and handler" do
+      assert_equal @handler_class, subject.handler_class
+      assert_instance_of @handler_class, subject.handler
+    end
+
+    should "not set its job, params or logger by default" do
+      assert_nil subject.job
+      assert_equal({}, subject.params)
+      assert_instance_of Qs::NullLogger, subject.logger
+    end
+
+    should "allow passing a job, params and logger" do
+      args = {
+        :job    => Factory.string,
+        :params => Factory.string,
+        :logger => Factory.string
+      }
+      runner = @runner_class.new(@handler_class, args)
+      assert_equal args[:job],    runner.job
+      assert_equal args[:params], runner.params
+      assert_equal args[:logger], runner.logger
+    end
+
+    should "raise a not implemented error when run" do
+      assert_raises(NotImplementedError){ subject.run }
+    end
+
+  end
+
+  class TestJobHandler
+    include Qs::JobHandler
+  end
+
+end

data/test/unit/test_helper_tests.rb

@@ -0,0 +1,61 @@
+require 'assert'
+require 'qs/test_helpers'
+
+require 'qs/job_handler'
+require 'test/support/runner_spy'
+
+module Qs::TestHelpers
+
+  class UnitTests < Assert::Context
+    desc "Qs::TestHelpers"
+    setup do
+      @test_helpers = Qs::TestHelpers
+    end
+    subject{ @test_helpers }
+
+  end
+
+  class MixinTests < UnitTests
+    desc "as a mixin"
+    setup do
+      context_class = Class.new{ include Qs::TestHelpers }
+      @context = context_class.new
+    end
+    subject{ @context }
+
+    should have_imeths :test_runner, :test_handler
+
+  end
+
+  class HandlerTestRunnerTests < MixinTests
+    desc "for handler testing"
+    setup do
+      @handler_class = Class.new
+      @args = { Factory.string => Factory.string }
+
+      @runner_spy = nil
+      Assert.stub(Qs::TestRunner, :new) do |*args|
+        @runner_spy = RunnerSpy.new(*args)
+      end
+    end
+
+    should "build a test runner for a given handler" do
+      result = subject.test_runner(@handler_class, @args)
+
+      assert_not_nil @runner_spy
+      assert_equal @handler_class, @runner_spy.handler_class
+      assert_equal @args, @runner_spy.args
+      assert_equal @runner_spy, result
+    end
+
+    should "return an initialized handler instance" do
+      result = subject.test_handler(@handler_class, @args)
+
+      assert_not_nil @runner_spy
+      assert_equal @runner_spy.handler, result
+    end
+
+  end
+
+end
+