stooge 0.1.0 → 0.1.1

data/HISTORY.md

@@ -1,5 +1,5 @@
 
-### 0.1.0 (2012-03-09)
+### 0.1.0 (2012-03-14)
 
 * Implemented same basic feature set as Minion (i.e. work queues)
 * Added ability to easily test job handlers

data/README.md

@@ -44,10 +44,10 @@ end
 Error handling
 --------------
 
-When an error is thrown in a job handler, the job is requeued to be done later and the Stooge process exits. If you define an error handler, however, the error handler is run and the job is removed from the queue.
+When an error is thrown in a job handler, the job is re-queued to be done later and the Stooge process exits. If you define an error handler, however, the error handler is run and the job is removed from the queue.
 
 ```ruby
-Stooge.error do |e|
+Stooge.error do |exception, handler, payload, headers|
   puts "got an error! #{e}"
 end
 ```

data/lib/stooge/handler.rb

@@ -30,23 +30,43 @@ module Stooge
       channel.queue(@queue_name, @queue_options) do |queue|
         queue.subscribe(:ack => true) do |metadata, payload|
           Stooge.log "recv: #{@queue_name}"
-          begin
-            case metadata.content_type
-            when 'application/json'
-              args = MultiJson.decode(payload)
-            else
-              args = payload
-            end
-            @block.call(args, metadata.headers)
-          rescue Object => e
-            if Stooge.error_handler
-              Stooge.error_handler.call(e,self,payload,metadata)
-            end
-          end
+          run(payload, metadata.content_type, metadata.headers)
           metadata.ack
         end
       end
     end
 
+    #
+    # Call the handler block. This method will rescue any exceptions the
+    # handler block raises and pass them on to the global error handler.
+    #
+    # @param [String] payload the message payload
+    # @param [String] content_type the MIME content type of the message
+    #   payload
+    # @param [Hash] headers the message headers
+    # 
+    # @return [Object] the return value of the handler block
+    #
+    def run(payload, content_type, headers)
+      @block.call(
+        decode_payload(payload, content_type),
+        headers)
+    rescue Object => e
+      if Stooge.error_handler
+        Stooge.error_handler.call(e,self,payload,headers)
+      end
+    end
+
+    private
+
+      def decode_payload(payload, content_type)
+        case content_type
+        when 'application/json'
+          MultiJson.decode(payload)
+        else
+          payload.to_s
+        end
+      end
+
   end
 end

data/lib/stooge/version.rb

@@ -1,3 +1,3 @@
 module Stooge
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/stooge/worker.rb

@@ -19,7 +19,7 @@ module Stooge
     # @return [Boolean] true or false
     #
     def self.run?
-      Stooge.handlers? &&
+      Stooge.has_handlers? &&
         File.expand_path($0) == File.expand_path(app_file)
     end
 

data/lib/stooge.rb

@@ -14,7 +14,7 @@ module Stooge
   @@connection = nil
   @@channel = nil
   @@handlers = []
-  @@error_handler = Proc.new do |exception, handler, payload, metadata|
+  @@error_handler = Proc.new do |exception, handler, payload, headers|
     Stooge.log "#{handler.queue_name} failed: #{exception.inspect}"
     raise exception
   end
@@ -71,12 +71,10 @@ module Stooge
   #
   # If you don't raise an exception in the error handler the job will be
   # acked with the broker and the broker will consider the job done and remove
-  # it from the queue. If you for some reason want to force the job to be
-  # acked even when you raise an error you can manually ack it before you
-  # raise the error, like this:
+  # it from the queue. To make sure the job is not lost you can simply
+  # re-raise the same exception in your custom handler:
   #
-  #   Stooge.error do |exception, handler, payload, metadata|
-  #     metadata.ack
+  #   Stooge.error do |exception, handler, payload, headers|
   #     raise exception
   #   end
   #
@@ -85,7 +83,7 @@ module Stooge
   # @yieldparam [Stooge::Handler] handler the handler that failed.
   # @yieldparam [Object] payload the message payload that was processed when
   #   the handler failed.
-  # @yieldparam [Hash] metadata the message metadata (headers, etc.)
+  # @yieldparam [Hash] headers the message headers
   #
   def error(&blk)
     @@error_handler = blk
@@ -124,10 +122,18 @@ module Stooge
   #
   # @return [Boolean] true or false
   #
-  def handlers?
+  def has_handlers?
     @@handlers.empty? == false
   end
 
+  #
+  # Remove all job handlers. Mainly useful in tests to create a clean slate
+  # for each test case.
+  #
+  def clear_handlers
+    @@handlers = []
+  end
+
   #
   # Execute a handler block without going through AMQP at all. This is a
   # helper method for use in tests. It allows you to test the business logic
@@ -148,7 +154,7 @@ module Stooge
   def run_handler(queue_name, data, headers = {})
     @@handlers.each do |handler|
       if handler.queue_name == queue_name
-        return handler.block.call(data, headers)
+        return handler.run(MultiJson.encode(data), 'application/json', headers)
       end
     end
   end

data/spec/stooge_spec.rb

@@ -6,4 +6,142 @@ require 'rspec'
 
 describe Stooge do
 
+  before do
+    Stooge.amqp_url = 'amqp://guest:guest@localhost/'
+    Stooge.clear_handlers
+  end
+
+  it 'should use a default URL to the AMQP broker' do
+    Stooge.amqp_url.should == 'amqp://guest:guest@localhost/'
+    Stooge.send(:amqp_config).should == {
+      :vhost => '/',
+      :host => 'localhost',
+      :user => 'guest',
+      :port => 5672,
+      :pass => 'guest'
+    }
+  end
+
+  it 'should be possible to configure the URL to the AMQP broker' do
+    Stooge.amqp_url = 'amqp://john:doe@example.com:5000/vhost'
+    Stooge.amqp_url.should == 'amqp://john:doe@example.com:5000/vhost'
+    Stooge.send(:amqp_config).should == {
+      :vhost => '/vhost',
+      :host => 'example.com',
+      :user => 'john',
+      :port => 5000,
+      :pass => 'doe'
+    }
+  end
+
+  it 'can add a job handler (ruby block) for a specified work queue' do
+    Stooge.job('test.work') {}
+    Stooge.should have_handlers
+  end
+
+  it 'can enqueue jobs on a named queue with data and headers if inside an EM synchrony block' do
+    EM.synchrony do
+      # Here we stub the call to #publish on the default exchange and
+      # intercept the published message instead of sending the message to the
+      # broker and then testing if the broker receieved a new message, which
+      # is very hard to do reliably because of timing issues and because the
+      # message is silently dropped by the broker if no queue is bound to the
+      # exchange. It also give us the ability to easily test that the message
+      # is published with the correct options.
+      Stooge.with_channel do |channel|
+        channel.default_exchange.should_receive(:publish).with(
+          '{"test":"test"}',
+          {
+            :routing_key => 'test.work',
+            :mandatory => true,
+            :content_type => 'application/json',
+            :headers => { :foo => 'bar' }
+          }).and_yield
+      end
+      Stooge.enqueue('test.work', { :test => 'test' }, :foo => 'bar')
+      Stooge.stop!
+    end
+  end
+
+  it 'can put a job on a queue and that job is the later picked up by a handler and processed' do
+    # This test is a bit tricky and might require some explanation. To
+    # actually test that this works we need to first create a job handler that
+    # sets a global ($work_performed) variable that we can later check to see
+    # wether the job has actually been performed. We then open an EM synchrony
+    # block in which we start the job handler (i.e. makes it listen to its
+    # queue for job messages). We then enqeue a job and later check if the job
+    # was performed as expected.
+    #
+    # To make all this work we need to deal with some nasty timing issues:
+    #
+    # 1. We need make sure the handler has had enough time to create a queue
+    #    and binding before we can publish a message, or the message will
+    #    just be silently dropped. This needs to happen in different EM tick.
+    #    We therefor add an EM timer to publish the message 1 second later.
+    #    The timer requires us to open up yet another synchrony block, because
+    #    the timer block does not execute inside the fiber created by
+    #    synchrony which it needs to do for Stooge#enqueue to work (because of
+    #    the deferable magic happening behind the scenes).
+    #
+    # 2. When we have published the message we then need to wait a while for
+    #    the job handler to pick it up and process it. We need to keep the
+    #    EM loop alive for this to happen, so we simply sleep for 1 second
+    #    before we shut the EM loop down and check if the job was processed.
+    # 
+    # NOTE: This all depend on the communication with the broker taking less
+    # than 1 second, which should be more than fine in most cases. If this
+    # test stops working for some reason the first thing to try should be to
+    # increase the wait time and see if it works then.
+    #
+    $work_performed = false
+    Stooge.job('test.work') { $work_performed = true }
+    EM.synchrony do
+      Stooge.with_channel do |channel|
+        Stooge.start_handlers(channel)
+      end
+      EM.add_timer(1) do
+        EM.synchrony do
+          Stooge.enqueue('test.work', { :test => 'test' }, :foo => 'bar')
+        end
+        sleep(1)
+        Stooge.stop!
+      end
+    end
+    $work_performed.should == true
+  end
+
+  it 'should be possible to specify a custom global error handler' do
+    $error = false
+    old_handler = Stooge.error_handler
+    Stooge.error do |exception, handler, payload, metadata|
+      $error = true
+    end
+    Stooge.job('test.work') { raise }
+    Stooge.run_handler('test.work', '')
+    Stooge.error(&old_handler)
+    $error.should == true
+  end
+
+  it 'should be possible to specify a custom logger' do
+    $logged = false
+    old_logger = Stooge.logger
+    Stooge.logger do |msg|
+      $logged = true
+    end
+    Stooge.log('test')
+    Stooge.logger(&old_logger)
+    $logged.should == true
+  end
+
+  it 'should be possible to test a handler' do
+    $work_performed = false
+    Stooge.job('test.work') do |args, headers|
+      $work_performed = true
+      args.should == { 'test' => 'test' }
+      headers.should == { :foo => 'bar' }
+    end
+    Stooge.run_handler('test.work', { :test => 'test' }, :foo => 'bar')
+    $work_performed.should == true
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stooge
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-14 00:00:00.000000000 Z
+date: 2012-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amqp
-  requirement: &70330131821100 !ruby/object:Gem::Requirement
+  requirement: &70114352031440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70330131821100
+  version_requirements: *70114352031440
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &70330131820660 !ruby/object:Gem::Requirement
+  requirement: &70114352031000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70330131820660
+  version_requirements: *70114352031000
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &70330131820200 !ruby/object:Gem::Requirement
+  requirement: &70114352030540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70330131820200
+  version_requirements: *70114352030540
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70330131819740 !ruby/object:Gem::Requirement
+  requirement: &70114352030080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70330131819740
+  version_requirements: *70114352030080
 description: Super advanced job queue over AMQP
 email:
 - niklas@sutajio.se