qs 0.3.0 → 0.4.0

data/test/unit/job_tests.rb

@@ -1,6 +1,8 @@
 require 'assert'
 require 'qs/job'
 
+require 'qs/message'
+
 class Qs::Job
 
   class UnitTests < Assert::Context
@@ -14,19 +16,12 @@ class Qs::Job
     end
     subject{ @job_class }
 
-    should have_imeths :parse
-
-    should "parse a job from a payload hash" do
-      payload = {
-        'name'       => @name,
-        'params'     => @params,
-        'created_at' => @created_at.to_i
-      }
-      job = subject.parse(payload)
-      assert_instance_of subject, job
-      assert_equal payload['name'], job.name
-      assert_equal payload['params'], job.params
-      assert_equal Time.at(payload['created_at']), job.created_at
+    should "know its payload type" do
+      assert_equal 'job', PAYLOAD_TYPE
+    end
+
+    should "be a message" do
+      assert subject < Qs::Message
     end
 
   end
@@ -37,94 +32,69 @@ class Qs::Job
       @current_time = Factory.time
       Assert.stub(Time, :now).with{ @current_time }
 
-      @job = @job_class.new(@name, @params, @created_at)
+      @job = @job_class.new(@name, {
+        :params     => @params,
+        :created_at => @created_at
+      })
     end
     subject{ @job }
 
-    should have_readers :name, :params, :created_at
-    should have_imeths :to_payload
+    should have_readers :name, :created_at
+    should have_imeths :route_name
 
-    should "know its name, params and created at" do
-      assert_equal @name,       subject.name
-      assert_equal @params,     subject.params
-      assert_equal @created_at, subject.created_at
+    should "know its attributes" do
+      assert_equal PAYLOAD_TYPE, subject.payload_type
+      assert_equal @name,         subject.name
+      assert_equal @params,       subject.params
+      assert_equal @created_at,   subject.created_at
     end
 
-    should "default its created at" do
-      job = @job_class.new(@name, @params)
+    should "default its params and created at to the current time" do
+      job = @job_class.new(@name)
+      assert_equal({}, job.params)
       assert_equal @current_time, job.created_at
     end
 
-    should "return a payload hash using `to_payload`" do
-      payload_hash = subject.to_payload
-      expected = {
-        'name'       => @name,
-        'params'     => @params,
-        'created_at' => @created_at.to_i
-      }
-      assert_equal expected, payload_hash
-    end
-
-    should "convert job names to strings using `to_payload`" do
-      job = @job_class.new(@name.to_sym, @params)
-      assert_equal @name, job.to_payload['name']
-    end
-
-    should "convert stringify its params using `to_payload`" do
-      params = { Factory.string.to_sym => Factory.string }
-      job = @job_class.new(@name, params)
-      exp = StringifyParams.new(params)
-      assert_equal exp, job.to_payload['params']
-    end
-
-    should "raise an error when given an invalid name or params" do
-      assert_raises(Qs::BadJobError){ @job_class.new(nil, @params) }
-      assert_raises(Qs::BadJobError){ @job_class.new(@name, nil) }
-      assert_raises(Qs::BadJobError){ @job_class.new(@name, Factory.string) }
+    should "know its route name" do
+      assert_same subject.name, subject.route_name
     end
 
     should "have a custom inspect" do
       reference = '0x0%x' % (subject.object_id << 1)
-      expected = "#<Qs::Job:#{reference} " \
-                 "@name=#{subject.name.inspect} " \
-                 "@params=#{subject.params.inspect} " \
-                 "@created_at=#{subject.created_at.inspect}>"
-      assert_equal expected, subject.inspect
+      exp = "#<Qs::Job:#{reference} " \
+            "@name=#{subject.name.inspect} " \
+            "@params=#{subject.params.inspect} " \
+            "@created_at=#{subject.created_at.inspect}>"
+      assert_equal exp, subject.inspect
     end
 
     should "be comparable" do
-      matching = @job_class.new(@name, @params, @created_at)
+      matching = @job_class.new(@name, {
+        :params     => @params,
+        :created_at => @created_at
+      })
       assert_equal matching, subject
-      non_matching = @job_class.new(Factory.string, @params, @created_at)
+
+      non_matching = @job_class.new(Factory.string, {
+        :params     => @params,
+        :created_at => @created_at
+      })
       assert_not_equal non_matching, subject
-      params = { Factory.string => Factory.string }
-      non_matching = @job_class.new(@name, params, @created_at)
+      non_matching = @job_class.new(@name, {
+        :params     => { Factory.string => Factory.string },
+        :created_at => @created_at
+      })
       assert_not_equal non_matching, subject
-      non_matching = @job_class.new(@name, @params, Factory.time)
+      non_matching = @job_class.new(@name, {
+        :params     => @params,
+        :created_at => Factory.time
+      })
       assert_not_equal non_matching, subject
     end
 
-  end
-
-  class StringifyParamsTests < UnitTests
-    desc "StringifyParams"
-    subject{ StringifyParams }
-
-    should have_imeths :new
-
-    should "convert all hash keys to strings" do
-      key, value = Factory.string.to_sym, Factory.string
-      result = subject.new({
-        key    => value,
-        :hash  => { key => [value] },
-        :array => [{ key => value }]
-      })
-      exp = {
-        key.to_s => value,
-        'hash'   => { key.to_s => [value] },
-        'array'  => [{ key.to_s => value }]
-      }
-      assert_equal exp, result
+    should "raise an error when given invalid attributes" do
+      assert_raises(InvalidError){ @job_class.new(nil) }
+      assert_raises(InvalidError){ @job_class.new(@name, :params => Factory.string) }
     end
 
   end

data/test/unit/message_handler_tests.rb

@@ -0,0 +1,235 @@
+require 'assert'
+require 'qs/message_handler'
+
+module Qs::MessageHandler
+
+  class UnitTests < Assert::Context
+    desc "Qs::MessageHandler"
+    setup do
+      @handler_class = Class.new{ include Qs::MessageHandler }
+    end
+    subject{ @handler_class }
+
+    should have_imeths :timeout
+    should have_imeths :before_callbacks, :after_callbacks
+    should have_imeths :before_init_callbacks, :after_init_callbacks
+    should have_imeths :before_run_callbacks,  :after_run_callbacks
+    should have_imeths :before, :after
+    should have_imeths :before_init, :after_init
+    should have_imeths :before_run,  :after_run
+    should have_imeths :prepend_before, :prepend_after
+    should have_imeths :prepend_before_init, :prepend_after_init
+    should have_imeths :prepend_before_run,  :prepend_after_run
+
+    should "allow reading/writing its timeout" do
+      assert_nil subject.timeout
+      value = Factory.integer
+      subject.timeout(value)
+      assert_equal value, subject.timeout
+    end
+
+    should "convert timeout values to floats" do
+      value = Factory.float.to_s
+      subject.timeout(value)
+      assert_equal value.to_f, subject.timeout
+    end
+
+    should "return an empty array by default using `before_callbacks`" do
+      assert_equal [], subject.before_callbacks
+    end
+
+    should "return an empty array by default using `after_callbacks`" do
+      assert_equal [], subject.after_callbacks
+    end
+
+    should "return an empty array by default using `before_init_callbacks`" do
+      assert_equal [], subject.before_init_callbacks
+    end
+
+    should "return an empty array by default using `after_init_callbacks`" do
+      assert_equal [], subject.after_init_callbacks
+    end
+
+    should "return an empty array by default using `before_run_callbacks`" do
+      assert_equal [], subject.before_run_callbacks
+    end
+
+    should "return an empty array by default using `after_run_callbacks`" do
+      assert_equal [], subject.after_run_callbacks
+    end
+
+    should "append a block to the before callbacks using `before`" do
+      subject.before_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.before(&block)
+      assert_equal block, subject.before_callbacks.last
+    end
+
+    should "append a block to the after callbacks using `after`" do
+      subject.after_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.after(&block)
+      assert_equal block, subject.after_callbacks.last
+    end
+
+    should "append a block to the before init callbacks using `before_init`" do
+      subject.before_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.before_init(&block)
+      assert_equal block, subject.before_init_callbacks.last
+    end
+
+    should "append a block to the after init callbacks using `after_init`" do
+      subject.after_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.after_init(&block)
+      assert_equal block, subject.after_init_callbacks.last
+    end
+
+    should "append a block to the before run callbacks using `before_run`" do
+      subject.before_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.before_run(&block)
+      assert_equal block, subject.before_run_callbacks.last
+    end
+
+    should "append a block to the after run callbacks using `after_run`" do
+      subject.after_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.after_run(&block)
+      assert_equal block, subject.after_run_callbacks.last
+    end
+
+    should "prepend a block to the before callbacks using `prepend_before`" do
+      subject.before_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_before(&block)
+      assert_equal block, subject.before_callbacks.first
+    end
+
+    should "prepend a block to the after callbacks using `prepend_after`" do
+      subject.after_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_after(&block)
+      assert_equal block, subject.after_callbacks.first
+    end
+
+    should "prepend a block to the before init callbacks using `prepend_before_init`" do
+      subject.before_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_before_init(&block)
+      assert_equal block, subject.before_init_callbacks.first
+    end
+
+    should "prepend a block to the after init callbacks using `prepend_after_init`" do
+      subject.after_init_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_after_init(&block)
+      assert_equal block, subject.after_init_callbacks.first
+    end
+
+    should "prepend a block to the before run callbacks using `prepend_before_run`" do
+      subject.before_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_before_run(&block)
+      assert_equal block, subject.before_run_callbacks.first
+    end
+
+    should "prepend a block to the after run callbacks using `prepend_after_run`" do
+      subject.after_run_callbacks << proc{ Factory.string }
+      block = Proc.new{ Factory.string }
+      subject.prepend_after_run(&block)
+      assert_equal block, subject.after_run_callbacks.first
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @runner  = FakeRunner.new
+      @handler = TestMessageHandler.new(@runner)
+    end
+    subject{ @handler }
+
+    should have_imeths :init, :init!, :run, :run!
+
+    should "know its params and logger" do
+      assert_equal @runner.params, subject.public_params
+      assert_equal @runner.logger, subject.public_logger
+    end
+
+    should "call `init!` and its before/after init callbacks using `init`" do
+      subject.init
+      assert_equal 1, subject.first_before_init_call_order
+      assert_equal 2, subject.second_before_init_call_order
+      assert_equal 3, subject.init_call_order
+      assert_equal 4, subject.first_after_init_call_order
+      assert_equal 5, subject.second_after_init_call_order
+    end
+
+    should "call `run!` and its before/after run callbacks using `run`" do
+      subject.run
+      assert_equal 1, subject.first_before_run_call_order
+      assert_equal 2, subject.second_before_run_call_order
+      assert_equal 3, subject.run_call_order
+      assert_equal 4, subject.first_after_run_call_order
+      assert_equal 5, subject.second_after_run_call_order
+    end
+
+    should "raise a not implemented error when `run!` by default" do
+      assert_raises(NotImplementedError){ @handler_class.new(@runner).run! }
+    end
+
+  end
+
+  class TestMessageHandler
+    include Qs::MessageHandler
+
+    attr_reader :first_before_init_call_order, :second_before_init_call_order
+    attr_reader :first_after_init_call_order, :second_after_init_call_order
+    attr_reader :first_before_run_call_order, :second_before_run_call_order
+    attr_reader :first_after_run_call_order, :second_after_run_call_order
+    attr_reader :init_call_order, :run_call_order
+
+    before_init{ @first_before_init_call_order = next_call_order }
+    before_init{ @second_before_init_call_order = next_call_order }
+
+    after_init{ @first_after_init_call_order = next_call_order }
+    after_init{ @second_after_init_call_order = next_call_order }
+
+    before_run{ @first_before_run_call_order = next_call_order }
+    before_run{ @second_before_run_call_order = next_call_order }
+
+    after_run{ @first_after_run_call_order = next_call_order }
+    after_run{ @second_after_run_call_order = next_call_order }
+
+    def init!
+      @init_call_order = next_call_order
+    end
+
+    def run!
+      @run_call_order = next_call_order
+    end
+
+    def public_params; params; end
+    def public_logger; logger; end
+
+    private
+
+    def next_call_order
+      @order ||= 0
+      @order += 1
+    end
+  end
+
+  class FakeRunner
+    attr_accessor :params, :logger
+
+    def initialize
+      @params = Factory.string
+      @logger = Factory.string
+    end
+  end
+
+end

data/test/unit/message_tests.rb

@@ -0,0 +1,64 @@
+require 'assert'
+require 'qs/message'
+
+class Qs::Message
+
+  class UnitTests < Assert::Context
+    desc "Qs::Message"
+    setup do
+      @payload_type  = Factory.string
+      @params        = { Factory.string => Factory.string }
+      @message_class = Qs::Message
+    end
+    subject{ @message_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @message = @message_class.new(@payload_type, :params => @params)
+    end
+    subject{ @message }
+
+    should have_readers :payload_type, :params
+    should have_imeths :route_id, :route_name
+
+    should "know its payload type and params" do
+      assert_equal @payload_type, subject.payload_type
+      assert_equal @params, subject.params
+    end
+
+    should "default its params" do
+      message = @message_class.new(@payload_type)
+      assert_equal({}, message.params)
+    end
+
+    should "know its route id" do
+      route_name = Factory.string
+      Assert.stub(subject, :route_name){ route_name }
+
+      exp = RouteId.new(@payload_type, route_name)
+      assert_equal exp, subject.route_id
+    end
+
+    should "raise a not implement error for its route name" do
+      assert_raises(NotImplementedError){ subject.route_name }
+    end
+
+  end
+
+  class RouteIdTests < UnitTests
+    desc "RouteId"
+    subject{ RouteId }
+
+    should have_imeths :new
+
+    should "build a route id given a payload type and a route name" do
+      exp = "#{@payload_type}|#{@name}"
+      assert_equal exp, subject.new(@payload_type, @name)
+    end
+
+  end
+
+end