micro_q 0.6.1 → 0.6.2

data/README.md

@@ -1,4 +1,4 @@
-# MicroQ
+# MicroQ [![Build Status](https://travis-ci.org/bnorton/micro_q.png)](https://travis-ci.org/bnorton/micro_q)
 
 MicroQ is a per-process asynchronous background queue.
 
@@ -18,6 +18,38 @@ Or install it:
 
 ## Usage
 
+```ruby
+# A typical worker
+class MyWorker
+  def perform
+    # do some performing here
+  end
+
+  def update(options = {})
+    # do some updating
+   end
+end
+```
+
+###Simple (default)
+
+```ruby
+# Using the async proxy API
+MyWorker.async.perform
+
+MyWorker.async.update(:user_id => user.id)
+
+# Through the raw push API
+MicroQ.push(:class => 'MyWorker') # Defaults to the perform method
+
+# With a custom method
+MicroQ.push(:class => 'MyWorker', :method => 'update', :args => [{:user_id => user.id}])
+```
+
+###Advanced
+
+###Custom Loaders
+
 ## Contributing
 
 1. Fork it

data/lib/micro_q/config.rb

@@ -1,11 +1,22 @@
 module MicroQ
   class Config
+    ##
+    # Configuration accessible via:
+    # 1. hash syntax   (config[:k] and config[:k] = val)
+    # 2. method syntax (config.k and config.k = val)
+    #
+    # To change the type of worker that is used simply assign
+    # a new worker class (after requiring the file).
+    #
     def initialize
       @data = {
         'workers' => 3,
         'timeout' => 120,
         'interval' => 5,
-        'middleware' => MicroQ::Middleware::Chain.new
+        'middleware' => Middleware::Chain.new,
+        'manager' => Manager::Default,
+        'worker' => Worker::Standard,
+        'queue' => Queue::Default
       }
     end
 

data/lib/micro_q/manager/default.rb

@@ -20,8 +20,8 @@ module MicroQ
       attr_reader :queue, :workers
 
       def initialize
-        @queue   = MicroQ::Queue::Default.new
-        @workers = MicroQ::Worker::Standard.pool(:size => MicroQ.config.workers)
+        @queue   = MicroQ.config.queue.new
+        @workers = MicroQ.config.worker.pool(:size => MicroQ.config.workers)
       end
 
       def start

data/lib/micro_q/manager.rb

@@ -1 +1,17 @@
 require 'micro_q/manager/default'
+
+##
+# The Manager interface
+#
+# The concrete manager implementation encapsulates a queue and
+# a pool of workers. The worker pool need only be a collection of
+# workers that can accept and perform messages.
+#
+# :method: start
+#   - Begin the run loop for message processing.
+#
+# Note that the default manager is a celluloid actor that reschedules
+# itself (via the after(seconds) { start }) call which is a recursive
+# call that executes asynchronously. This behavior is critical and
+# therefore the class must `include Celluloid`.
+#

data/lib/micro_q/methods/action_mailer.rb

@@ -0,0 +1,17 @@
+module MicroQ
+  module Methods
+    module ActionMailer
+      def async
+        MicroQ::Proxy::ActionMailer.new(
+          :class => MicroQ::Wrapper::ActionMailer,
+          :base => self
+        )
+      end
+    end
+  end
+end
+
+MicroQ::Util.safe_require 'action_mailer'
+if defined?(ActionMailer::Base)
+  ActionMailer::Base.send(:extend, MicroQ::Methods::ActionMailer)
+end

data/lib/micro_q/methods/active_record.rb

@@ -1,5 +1,18 @@
 module MicroQ
   module Methods
+    ##
+    # Methods that are added to AR instances
+    #
+    # When processing instance methods asynchronously, AR objects
+    # should not be stored. Instances that are backed by a database
+    # are herby serialized and re-queried from the DB at runtime.
+    # For AR that means simply storing the class and adding a custom 'loader'
+    #
+    # A Loader is an additional step before a method is invoked that
+    # generates a target object from a method invocation and arguments.
+    # In the case of AR, what better then 'find'. Here we simply
+    # store the id as the argument for find.
+    #
     module ActiveRecord
       def async
         options = {
@@ -16,6 +29,7 @@ module MicroQ
   end
 end
 
+MicroQ::Util.safe_require 'active_record'
 if defined?(ActiveRecord::Base)
   ActiveRecord::Base.send(:include, MicroQ::Methods::ActiveRecord)
 end

data/lib/micro_q/methods/class.rb

@@ -1,5 +1,13 @@
 module MicroQ
   module Methods
+    ##
+    # Methods that are added to all Ruby Objects (as class methods).
+    #
+    # When processing class methods asynchronously, simply store
+    # the calling class. The custom 'loader' describes that no
+    # additional methods need be called to generate the callee of the
+    # message invocation
+    #
     module Class
       extend MicroQ::Methods::SharedMethods
 

data/lib/micro_q/methods/instance.rb

@@ -1,5 +1,15 @@
 module MicroQ
   module Methods
+    ##
+    # Methods that are added to all Ruby Objects (as instance methods).
+    #
+    # When processing instance methods asynchronously, simply store
+    # the calling instances' class name. No custom 'loader' is needed but
+    # since the worker defines a default 'loader'. An example loader for
+    # a messages invoked as MyWorker.new.perform(123), is
+    # :loader => { :method => 'new', :args => []} which happens to be
+    # what the default worker does.
+    #
     module Instance
       include MicroQ::Methods::SharedMethods
 

data/lib/micro_q/methods.rb

@@ -4,7 +4,7 @@ module MicroQ
       def method_missing(method, *other)
         super unless /((.+)\_async$)/ === method
 
-        name = $2 && $2.to_sym
+        name = $2
 
         # Define the method and call through.
         if name && respond_to?(name)
@@ -21,5 +21,9 @@ module MicroQ
   end
 end
 
+# add Class and Instance methods first then
+# override with additional extensions
 require 'micro_q/methods/class'
 require 'micro_q/methods/instance'
+require 'micro_q/methods/active_record'
+require 'micro_q/methods/action_mailer'

data/lib/micro_q/middleware/chain.rb

@@ -1,4 +1,5 @@
 require 'micro_q/middleware/server/retry'
+require 'micro_q/middleware/server/connection'
 
 module MicroQ
   module Middleware
@@ -90,7 +91,8 @@ module MicroQ
       class Server < Base
         def initialize
           @entries = [
-            MicroQ::Middleware::Server::Retry
+            MicroQ::Middleware::Server::Retry,
+            MicroQ::Middleware::Server::Connection
           ]
         end
       end

data/lib/micro_q/middleware/server/connection.rb

@@ -0,0 +1,15 @@
+module MicroQ
+  module Middleware
+    module Server
+      class Connection
+        def call(*)
+          yield
+        ensure
+          if defined?(ActiveRecord::Base)
+            ActiveRecord::Base.clear_active_connections!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/micro_q/middleware.rb

@@ -1 +1,14 @@
 require 'micro_q/middleware/chain'
+
+##
+# The Middleware interface
+#
+# Middleware is invoked around the processing of a message, either
+# on the 'client' (when the message is pushed to a queue) or on the
+# 'server' (when the message is being executed).
+#
+# :method: call
+#   - :args: (worker, message)
+#     worker is the target object in the method invocation specified by the message
+#     message the raw payload as de-queued by the queue
+#

data/lib/micro_q/proxies/action_mailer.rb

@@ -0,0 +1,19 @@
+module MicroQ
+  module Proxy
+    class ActionMailer < Base
+      def method_missing(meth, *args)
+        @args = [@options.delete(:base).to_s, meth.to_s, *args]
+
+        defaults = [{
+          :class => MicroQ::Wrapper::ActionMailer,
+          :method => 'perform',
+          :args => @args
+        }.merge(@options)]
+
+        defaults << { :when => at } if at
+
+        MicroQ.push(*defaults)
+      end
+    end
+  end
+end

data/lib/micro_q/proxies/base.rb

@@ -18,11 +18,11 @@ module MicroQ
         @method = meth.to_s
         @args = args
 
-        defaults = [@options.merge(
+        defaults = [{
           :class => klass,
           :method => method,
           :args => args
-        )]
+        }.merge(@options)]
 
         defaults << { :when => at } if at
 

data/lib/micro_q/proxies.rb

@@ -1,3 +1,4 @@
 require 'micro_q/proxies/base'
 require 'micro_q/proxies/class'
 require 'micro_q/proxies/instance'
+require 'micro_q/proxies/action_mailer'

data/lib/micro_q/queue/default.rb

@@ -10,8 +10,8 @@ module MicroQ
     # item = { 'class' => 'MyWorker', 'args' => [user.id] }
     #
     # queue = MicroQ::Queue::Default.new
-    # queue.push(item)       # synchronous push
-    # queue.async.push(item) # asynchronous push (preferred)
+    # queue.push(item)       # asynchronous push (preferred)
+    # queue.sync_push(item)  # synchronous push
     #
     # queue.entries
     # #=> [{'class' => 'MyWorker', 'args' => [32]}]
@@ -32,23 +32,32 @@ module MicroQ
       end
 
       ##
-      # Push a message item to the queue.
+      # Asynchronously push a message item to the queue.
+      #
+      def push(item, options={})
+        async.sync_push(item, options)
+      end
+
+      ##
+      # Synchronously push a message item to the queue.
       # Either push it to the immediate portion of the queue or store it for after when
       # it should be run with the 'when' option.
       #
       # Options:
       #   when: The time/timestamp after which to run the message.
       #
-      def push(item, options={})
+      def sync_push(item, options={})
         item, options = before_push(item, options)
 
-        if (time = options['when'])
-          @later.push(
-            'when' => time.to_f,
-            'worker' => item
-          )
-        else
-          @entries.push(item)
+        MicroQ.middleware.client.call(item['class'], item, options) do
+          if (time = options['when'])
+            @later.push(
+              'when' => time.to_f,
+              'worker' => item
+            )
+          else
+            @entries.push(item)
+          end
         end
       end
 

data/lib/micro_q/queue.rb

@@ -1 +1,24 @@
 require 'micro_q/queue/default'
+
+##
+# The Queueing interface
+#
+# The concrete queue implementations will all have something simple in
+# common. The queue stores and returns data. The logic used for
+# selecting the next items to return is critical but not relevant to the
+# rest of the system nor to the interface.
+#
+# :method: push
+#   - Add items to the backing data store
+#   - :args: (message, options)
+#     message is the hash the represents an pushed item
+#     options are for items that dont require storing in the message itself
+#       but are important in queueing.
+# :method: dequeue
+#   - Remove and return items from the data store
+#
+# You are otherwise able to implement this class in any suitable manner.
+# If adhering to the other conventions around data structures, keys, etc,
+#  then it will be easier to use the other types of classes required for
+#  micro_q to work properly.
+#

data/lib/micro_q/util.rb

@@ -13,9 +13,12 @@ module MicroQ
       end
       constant
     rescue
-      nil
     end
 
+    ##
+    # Copy a hash and convert all keys to strings.
+    # Stringifies to infinite hash depth
+    #
     def self.stringify_keys(hash)
       {}.tap do |result|
         hash.keys.each do |key|
@@ -25,5 +28,13 @@ module MicroQ
         end
       end
     end
+
+    ##
+    # Attempt to load a library but return nil if it cannot be loaded
+    #
+    def self.safe_require(lib)
+      require lib
+    rescue LoadError
+    end
   end
 end

data/lib/micro_q/version.rb

@@ -1,7 +1,7 @@
 module MicroQ
   MAJOR = 0
   MINOR = 6
-  POINT = 1
+  POINT = 2
 
   VERSION = [MAJOR, MINOR, POINT].join('.')
 end

data/lib/micro_q/worker.rb

@@ -1 +1,17 @@
 require 'micro_q/worker/standard'
+
+##
+# The Worker interface
+#
+# The concrete worker implementation is the member of the chain that
+# actually invokes the middleware chain and executes/performs the given
+# message.
+#
+# :method: perform
+#   - Re-hydrates and invokes the methods that the message specifies.
+#   - :args: (message)
+#     message is the hash the represents an pushed item
+#
+# Based on what keys are pushed to and de-queued from the queue,
+# do the actions that the message specifies.
+#

data/lib/micro_q/wrappers/action_mailer.rb

@@ -0,0 +1,11 @@
+module MicroQ
+  module Wrapper
+    class ActionMailer
+      def perform(klass, method, *args)
+        email = MicroQ::Util.constantize(klass).send(method, *args)
+
+        email.deliver if email.respond_to?(:deliver)
+      end
+    end
+  end
+end

data/lib/micro_q/wrappers.rb

@@ -0,0 +1 @@
+require 'micro_q/wrappers/action_mailer'

data/lib/micro_q.rb

@@ -21,14 +21,14 @@ module MicroQ
   end
 
   def self.push(*args)
-    manager.queue.async.push(*args)
+    manager.queue.push(*args)
   end
 
   private
 
   def self.manager
     @manager ||= begin
-      Manager::Default.new.tap do |manager|
+      config.manager.new.tap do |manager|
         manager.start!
       end
     end
@@ -40,6 +40,7 @@ module MicroQ
 end
 
 require 'micro_q/middleware'
+require 'micro_q/wrappers'
 require 'micro_q/methods'
 require 'micro_q/proxies'
 require 'micro_q/worker'

data/micro_q.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |gem|
   gem.name          = "micro_q"
   gem.version       = MicroQ::VERSION
   gem.authors       = ["Brian Norton"]
-  gem.email         = ["brian.nort@gmail.com"]
+  gem.email         = "brian.nort@gmail.com"
   gem.description   = ""
   gem.summary       = ""
   gem.homepage      = "http://github.com/bnorton/micro-q"
@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^spec/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = %w(lib)
 
   gem.add_dependency             "celluloid"
   gem.add_development_dependency "rake"
@@ -23,5 +23,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "timecop"
   gem.add_development_dependency "psych"
   gem.add_development_dependency "activerecord", "> 3.2.0"
+  gem.add_development_dependency "actionmailer", "> 3.2.0"
   gem.add_development_dependency "sqlite3-ruby"
 end

data/spec/lib/config_spec.rb

@@ -43,5 +43,17 @@ describe MicroQ::Config do
     it 'should not have a logfile' do
       subject.logfile.should == nil
     end
+
+    it 'should have the default queue' do
+      subject.manager.should == MicroQ::Manager::Default
+    end
+
+    it 'should have the default queue' do
+      subject.queue.should == MicroQ::Queue::Default
+    end
+
+    it 'should have the standard worker' do
+      subject.worker.should == MicroQ::Worker::Standard
+    end
   end
 end

data/spec/lib/methods/action_mailer_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe MicroQ::Methods::ActionMailer do
+  class MyMailer < ActionMailer::Base
+  end
+
+  describe '.async' do
+    let(:async) { -> { MyMailer.async } }
+
+    it 'should create a mailer proxy' do
+      MicroQ::Proxy::ActionMailer.should_receive(:new)
+
+      async.call
+    end
+
+    it 'should have the class' do
+      MicroQ::Proxy::ActionMailer.should_receive(:new).with(hash_including(:class => MicroQ::Wrapper::ActionMailer))
+
+      async.call
+    end
+
+    it 'should have the base class' do
+      MicroQ::Proxy::ActionMailer.should_receive(:new).with(hash_including(:base => MyMailer))
+
+      async.call
+    end
+  end
+end

data/spec/lib/methods/active_record_spec.rb

@@ -18,7 +18,7 @@ describe MicroQ::Methods::ActiveRecord, :active_record => true do
       MicroQ::Proxy::Instance.stub(:new).and_return(@proxy)
     end
 
-    it 'should create a proxy' do
+    it 'should create an instance proxy' do
       MicroQ::Proxy::Instance.should_receive(:new).and_return(@proxy)
 
       method.call

data/spec/lib/micro_q_spec.rb

@@ -64,15 +64,14 @@ describe MicroQ do
     end
 
     before do
-      @async = mock(Celluloid::AsyncProxy)
-      @manager = mock(MicroQ::Manager::Default, :start! => nil, :queue => mock("Queue", :async => @async))
+      @manager = mock(MicroQ::Manager::Default, :start! => nil, :queue => mock("Queue"))
       MicroQ::Manager::Default.stub(:new).and_return(@manager)
 
       MicroQ.start
     end
 
     it 'should delegate to the manager\'s queue' do
-      @async.should_receive(:push).with(*args)
+      @manager.queue.should_receive(:push).with(*args)
 
       push
     end

data/spec/lib/middleware/chain_spec.rb

@@ -205,14 +205,14 @@ describe MicroQ::Middleware::Chain do
     end
 
     describe 'defaults' do
-      [MicroQ::Middleware::Server::Retry].each do |klass|
+      [MicroQ::Middleware::Server::Retry, MicroQ::Middleware::Server::Connection].each do |klass|
         it "should include #{klass}" do
           subject.server.entries.should include(klass)
         end
       end
 
-      it 'should be 1 item long' do
-        subject.server.entries.should have(1).items
+      it 'should be 2 items long' do
+        subject.server.entries.should have(2).items
       end
     end
   end
@@ -238,29 +238,40 @@ describe MicroQ::Middleware::Chain do
     class MyWorker
     end
 
-    before do
-      @retry = mock(MicroQ::Middleware::Server::Retry)
-      MicroQ::Middleware::Server::Retry.stub(:new).and_return(@retry)
-    end
-
     describe 'server' do
       def call
-        subject.server.call(worker, payload)
+        subject.server.call(worker, payload) { }
       end
 
-      it 'should make a new middleware chain' do
-        subject.server.entries.each do |entry|
-          entry.should_receive(:new).and_return(mock('entry', :call => nil))
-        end
+      it 'should make a new retry instance' do
+        MicroQ::Middleware::Server::Retry.should_receive(:new).and_call_original
+
+        call
+      end
+
+      it 'should make a new connections instance' do
+        MicroQ::Middleware::Server::Connection.should_receive(:new).and_call_original
 
         call
       end
 
-      it 'should call each item' do
+      it 'should call the retry middleware' do
+        @retry = mock(MicroQ::Middleware::Server::Retry)
+        MicroQ::Middleware::Server::Retry.stub(:new).and_return(@retry)
+
         @retry.should_receive(:call).with(worker, payload)
 
         call
       end
+
+      it 'should call the connection middleware' do
+        @connection = mock(MicroQ::Middleware::Server::Connection)
+        MicroQ::Middleware::Server::Connection.stub(:new).and_return(@connection)
+
+        @connection.should_receive(:call).with(worker, payload)
+
+        call
+      end
     end
   end
 end

data/spec/lib/middleware/server/connection_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'active_record'
+
+describe MicroQ::Middleware::Server::Connection, :middleware => true do
+  describe '#call' do
+    let(:foo) { mock("Foo", :bar => nil) }
+    let(:block) { -> { foo.bar } }
+
+    def call
+      subject.call @worker, @payload, &block
+    end
+
+    it 'should execute the block' do
+      foo.should_receive(:bar)
+
+      call
+    end
+
+    describe 'active_record' do
+      it 'should clear active connections' do
+        ActiveRecord::Base.should_receive(:clear_active_connections!)
+
+        call
+      end
+
+      describe 'when the job raises an exception' do
+        let(:block) { -> { raise } }
+
+        it 'should error' do
+          expect {
+            call
+          }.to raise_error
+        end
+
+        it 'should clear active connections' do
+          ActiveRecord::Base.should_receive(:clear_active_connections!)
+
+          safe(:call)
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/middleware/server/retry_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe MicroQ::Middleware::Server::Retry, :middleware => true do
   describe '#call' do
     let(:foo) { mock("Foo", :bar => nil) }
-    let(:block) { lambda { foo.bar } }
+    let(:block) { -> { foo.bar } }
 
     def call
       subject.call @worker, @payload, &block

data/spec/lib/proxies/action_mailer_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe MicroQ::Proxy::ActionMailer do
+  let(:method) { lambda {|*args| subject.mail_me(*args) } }
+  let(:options) { { :class => MicroQ::Wrapper::ActionMailer, :base => MyMailer } }
+
+  class MyMailer < ActionMailer::Base
+  end
+
+  subject { MicroQ::Proxy::ActionMailer.new(options) }
+
+  describe 'method invocations' do
+    let(:method) { -> { subject.some_method(1, 2) } }
+
+    it 'should push the message' do
+      MicroQ.should_receive(:push)
+
+      method.call
+    end
+
+    it 'should have the class' do
+      MicroQ.should_receive(:push).with(hash_including(:class => MicroQ::Wrapper::ActionMailer))
+
+      method.call
+    end
+
+    it 'should have the method' do
+      MicroQ.should_receive(:push).with(hash_including(:method => 'perform'))
+
+      method.call
+    end
+
+    it 'should have the args' do
+      MicroQ.should_receive(:push).with(hash_including(:args => ['MyMailer', 'some_method', 1, 2]))
+
+      method.call
+    end
+
+    describe 'when performing at a specific time' do
+      before do
+        options[:at] = Time.now + 60
+      end
+
+      it 'should push with the right \'when\' key' do
+        MicroQ.should_receive(:push).with(anything, :when => (Time.now + 60).to_i)
+
+        method.call
+      end
+    end
+  end
+end

data/spec/lib/queue/default_spec.rb

@@ -13,17 +13,17 @@ describe MicroQ::Queue::Default do
     end
   end
 
-  describe '#push' do
-    let(:item) { { 'class' => 'MyWorker', 'args' => [] } }
+  describe '#sync_push' do
+    let(:item) { { 'class' => 'MyWorker', 'args' => [4] } }
 
     it 'should add to the entries' do
-      subject.push(item)
+      subject.sync_push(item)
 
       subject.entries.should include(item)
     end
 
     it 'should duplicate the item' do
-      subject.push(item)
+      subject.sync_push(item)
 
       before = item.dup
       subject.entries.should include(before)
@@ -33,11 +33,24 @@ describe MicroQ::Queue::Default do
       subject.entries.should include(before)
     end
 
+    describe 'client middleware' do
+      it 'should process the middleware chain' do
+        MicroQ.middleware.client.should_receive(:call) do |w, payload|
+          w.should == 'MyWorker'
+
+          payload['class'].should == 'MyWorker'
+          payload['args'].should == [4]
+        end
+
+        subject.sync_push(item)
+      end
+    end
+
     describe 'when given the "when" key' do
       let(:worker) { [item, { 'when' => (Time.now + 100).to_i }] }
 
       it 'should add to the later' do
-        subject.push(*worker)
+        subject.sync_push(*worker)
 
         subject.later.should include(
           'when' => (Time.now + 100).to_i,
@@ -46,17 +59,29 @@ describe MicroQ::Queue::Default do
       end
 
       it 'should not be in the entries' do
-        subject.push(*worker)
+        subject.sync_push(*worker)
 
         subject.entries.should == []
       end
+
+      it 'should process the middleware chain' do
+        MicroQ.middleware.client.should_receive(:call) do |w, payload, options|
+          w.should == 'MyWorker'
+
+          payload['class'].should == 'MyWorker'
+          payload['args'].should == [4]
+          options['when'].should == (Time.now + 100).to_i
+        end
+
+        subject.sync_push(*worker)
+      end
     end
 
     describe 'when given the symbol :when key' do
       let(:worker) { [item, { :when => (Time.now + 100).to_i }] }
 
       it 'should add to the later' do
-        subject.push(*worker)
+        subject.sync_push(*worker)
 
         subject.later.should include(
           'when' => (Time.now + 100).to_i,
@@ -65,13 +90,28 @@ describe MicroQ::Queue::Default do
       end
 
       it 'should not be in the entries' do
-        subject.push(*worker)
+        subject.sync_push(*worker)
 
         subject.entries.should == []
       end
     end
   end
 
+  describe '#push' do
+    let(:item) { { 'class' => 'MyWorker', 'args' => [4] } }
+
+    before do
+      @async = mock(Celluloid::ActorProxy)
+      subject.stub(:async).and_return(@async)
+    end
+
+    it 'should asynchronously push the item' do
+      @async.should_receive(:sync_push).with(*item)
+
+      subject.push(*item)
+    end
+  end
+
   describe '#dequeue' do
     let(:item) { { 'class' => 'MyWorker', 'args' => [] } }
 
@@ -82,7 +122,7 @@ describe MicroQ::Queue::Default do
 
     describe 'when there are entries' do
       before do
-        subject.push(item)
+        subject.sync_push(item)
       end
 
       it 'should return the item' do
@@ -98,7 +138,7 @@ describe MicroQ::Queue::Default do
 
     describe 'when there are items to be processed later' do
       before do
-        subject.push(item, 'when' => (Time.now + 5).to_i)
+        subject.sync_push(item, 'when' => (Time.now + 5).to_i)
       end
 
       it 'should not return the item' do
@@ -137,10 +177,10 @@ describe MicroQ::Queue::Default do
       end
 
       before do
-        items.first(4).each {|item| subject.push(item) }
-        subject.push(items.last, 'when' => (Time.now - 2).to_i)
+        items.first(4).each {|item| subject.sync_push(item) }
+        subject.sync_push(items.last, 'when' => (Time.now - 2).to_i)
 
-        subject.push(*later_item)
+        subject.sync_push(*later_item)
       end
 
       it 'should return all the available items' do

data/spec/lib/util_spec.rb

@@ -48,4 +48,29 @@ describe MicroQ::Util do
       }
     end
   end
+
+  describe '.safe_require' do
+    def req(lib)
+      MicroQ::Util.safe_require(lib)
+    end
+
+    it 'should require the file' do
+      defined?(CMath).should == nil
+      req('cmath')
+
+      defined?(CMath).should == 'constant'
+    end
+
+    describe 'when the library is not available' do
+      it 'should not error' do
+        expect {
+          req('foo-bar-baz')
+        }.not_to raise_error
+      end
+
+      it 'should be nil' do
+        req('foo-bar-baz').should == nil
+      end
+    end
+  end
 end

data/spec/wrappers/action_mailer_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe MicroQ::Wrapper::ActionMailer do
+  class MyMailer
+    def self.mail_me
+    end
+  end
+
+  describe '#perform' do
+    let(:mail) { mock("email", :deliver => nil) }
+
+    def perform
+      subject.perform('MyMailer', 'mail_me', 1, 2)
+    end
+
+    before do
+      MyMailer.stub(:mail_me).and_return(mail)
+    end
+
+    it 'should call the mailer method' do
+      MyMailer.should_receive(:mail_me).and_return(mail)
+
+      perform
+    end
+
+    it 'should pass the arguments' do
+      MyMailer.should_receive(:mail_me).with(1, 2).and_return(mail)
+
+      perform
+    end
+
+    it 'should deliver the email' do
+      mail.should_receive(:deliver)
+
+      perform
+    end
+
+    describe 'when the email does not work' do
+      let(:mail) { mock("email without deliver") }
+
+      before do
+        mail.stub(:respond_to?).with(:deliver).and_return(false)
+      end
+
+      it 'should not error' do
+        expect {
+          perform
+        }.not_to raise_error
+      end
+
+      it 'should not deliver the message' do
+        mail.should_not_receive(:deliver)
+
+        perform
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: micro_q
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-04 00:00:00.000000000 Z
+date: 2013-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -107,6 +107,22 @@ dependencies:
     - - ! '>'
       - !ruby/object:Gem::Version
         version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -124,8 +140,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: ''
-email:
-- brian.nort@gmail.com
+email: brian.nort@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -142,13 +157,16 @@ files:
 - lib/micro_q/manager.rb
 - lib/micro_q/manager/default.rb
 - lib/micro_q/methods.rb
+- lib/micro_q/methods/action_mailer.rb
 - lib/micro_q/methods/active_record.rb
 - lib/micro_q/methods/class.rb
 - lib/micro_q/methods/instance.rb
 - lib/micro_q/middleware.rb
 - lib/micro_q/middleware/chain.rb
+- lib/micro_q/middleware/server/connection.rb
 - lib/micro_q/middleware/server/retry.rb
 - lib/micro_q/proxies.rb
+- lib/micro_q/proxies/action_mailer.rb
 - lib/micro_q/proxies/base.rb
 - lib/micro_q/proxies/class.rb
 - lib/micro_q/proxies/instance.rb
@@ -158,16 +176,21 @@ files:
 - lib/micro_q/version.rb
 - lib/micro_q/worker.rb
 - lib/micro_q/worker/standard.rb
+- lib/micro_q/wrappers.rb
+- lib/micro_q/wrappers/action_mailer.rb
 - micro_q.gemspec
 - spec/helpers/methods_examples.rb
 - spec/lib/config_spec.rb
 - spec/lib/manager/default_spec.rb
+- spec/lib/methods/action_mailer_spec.rb
 - spec/lib/methods/active_record_spec.rb
 - spec/lib/methods/class_spec.rb
 - spec/lib/methods/instance_spec.rb
 - spec/lib/micro_q_spec.rb
 - spec/lib/middleware/chain_spec.rb
+- spec/lib/middleware/server/connection_spec.rb
 - spec/lib/middleware/server/retry_spec.rb
+- spec/lib/proxies/action_mailer_spec.rb
 - spec/lib/proxies/base_spec.rb
 - spec/lib/proxies/class_spec.rb
 - spec/lib/proxies/instance_spec.rb
@@ -175,6 +198,7 @@ files:
 - spec/lib/util_spec.rb
 - spec/lib/worker/standard_spec.rb
 - spec/spec_helper.rb
+- spec/wrappers/action_mailer_spec.rb
 homepage: http://github.com/bnorton/micro-q
 licenses: []
 post_install_message: 
@@ -203,12 +227,15 @@ test_files:
 - spec/helpers/methods_examples.rb
 - spec/lib/config_spec.rb
 - spec/lib/manager/default_spec.rb
+- spec/lib/methods/action_mailer_spec.rb
 - spec/lib/methods/active_record_spec.rb
 - spec/lib/methods/class_spec.rb
 - spec/lib/methods/instance_spec.rb
 - spec/lib/micro_q_spec.rb
 - spec/lib/middleware/chain_spec.rb
+- spec/lib/middleware/server/connection_spec.rb
 - spec/lib/middleware/server/retry_spec.rb
+- spec/lib/proxies/action_mailer_spec.rb
 - spec/lib/proxies/base_spec.rb
 - spec/lib/proxies/class_spec.rb
 - spec/lib/proxies/instance_spec.rb
@@ -216,4 +243,5 @@ test_files:
 - spec/lib/util_spec.rb
 - spec/lib/worker/standard_spec.rb
 - spec/spec_helper.rb
+- spec/wrappers/action_mailer_spec.rb
 has_rdoc: