ayl-beanstalk 0.3.0 → 0.4.0

data/lib/ayl-beanstalk.rb

@@ -1,5 +1,6 @@
 require 'ayl'
-require 'beanstalk-client'
+require 'beaneater'
+require 'json'
 require 'ayl-beanstalk/job'
 require 'ayl-beanstalk/exceptions'
 require 'ayl-beanstalk/pool'

data/lib/ayl-beanstalk/engine.rb

@@ -20,7 +20,7 @@ module Ayl
         connected = true
         begin
           pool
-        rescue ::Beanstalk::NotConnected => ex
+        rescue ::Beaneater::NotConnected => ex
           logger.error "#{self.class.name} not connected error: #{ex}"
           connected = false
         end
@@ -30,10 +30,13 @@ module Ayl
       def submit(message)
         log_call(:submit) do
           begin
-            pool.use(message.options.queue_name)
+            tube = pool.tubes[message.options.queue_name]
             code = message.to_rrepr
             logger.info "#{self.class.name} submitting '#{code}' to tube '#{message.options.queue_name}'"
-            pool.yput(message.to_hash, message.options.priority, message.options.delay, message.options.time_to_run)
+            tube.put(message.to_hash.to_json, 
+                     pri: message.options.priority, 
+                     delay: message.options.delay, 
+                     ttr: message.options.time_to_run)
           rescue Exception => ex
             logger.error "Error submitting message to beanstalk: #{ex}"
             Ayl::Mailer.instance.deliver_message("Error submitting message to beanstalk", ex)

data/lib/ayl-beanstalk/job.rb

@@ -5,7 +5,7 @@
 #
 # I promise that no methods overridden here; only new methods added.
 #
-class Beanstalk::Job
+class Beaneater::Job
   include Ayl::Logging
 
   #
@@ -13,7 +13,7 @@ class Beanstalk::Job
   # formatted, then nil is returned.
   #
   def ayl_message
-    @msg ||= Ayl::Message.from_hash(ybody)
+    @msg ||= Ayl::Message.from_hash(JSON.parse(body))
   rescue Ayl::UnrecoverableMessageException => ex
     logger.error "Error extracting message from beanstalk job: #{ex}"
     Ayl::Mailer.instance.deliver_message "Error extracting message from beanstalk job", ex
@@ -36,7 +36,9 @@ class Beanstalk::Job
   # process.
   #
   def ayl_decay(delay=nil)
-    decay(*[ delay ].compact)
+    options = {}
+    options[:delay] = delay unless delay.nil?
+    release(options)
   rescue Exception => ex
     logger.error "Error decaying job: #{ex}\n#{ex.backtrace.join("\n")}"
     Ayl::Mailer.instance.deliver_message("Error decaying job", ex)
@@ -53,20 +55,22 @@ class Beanstalk::Job
     Ayl::Mailer.instance.deliver_message("Error decaying job", ex)
   end
 
+  def reserves
+    stats['reserves']
+  end
+  #
+  # If this job message has been configured for 'decay' handling,
+  # then the rules are as follows:
   #
-  # Handle the decay process by deleting the job if its age is more than
-  # 60 seconds, but delaying it if it is younger than 60 seconds. Obviously
-  # we want to handle any exceptions that occur here.
   #
   def handle_decay(ex)
-    logger.debug "Age of job: #{age}"
-    if age > 60
-      Ayl::Mailer.instance.deliver_message("Deleting decayed job; it just took too long.", ex)
-      logger.debug "Deleting job"
-      ayl_delete
+    if reserves < ayl_message.options.failed_job_count
+      ayl_decay ayl_message.options.failed_job_delay
     else
-      logger.debug "Decaying job"
-      ayl_decay
+      # This job has already been reserved too many times.
+      # Bury it.
+      ayl_bury
+      Ayl::Mailer.instance.burying_job(ayl_message.code)
     end
   end
 

data/lib/ayl-beanstalk/pool.rb

@@ -5,7 +5,7 @@ module Ayl
     module Pool
 
       def pool
-        @pool ||= ::Beanstalk::Pool.new([ "#{@host}:#{@port}" ])
+        @pool ||= ::Beaneater.new("#{@host}:#{@port}")
       end
 
     end

data/lib/ayl-beanstalk/worker.rb

@@ -16,7 +16,7 @@ module Ayl
         logger.debug "#{self.class.name} entering process_messages loop watching: #{Ayl::MessageOptions.default_queue_name}"
 
         # Set the queue that we will be watching
-        pool.watch(Ayl::MessageOptions.default_queue_name)
+        pool.tubes.watch!(Ayl::MessageOptions.default_queue_name)
 
         reserve_job do | job |
           begin
@@ -68,7 +68,7 @@ module Ayl
           begin
 
             # Sit around and wait for a job to become available
-            job = pool.reserve
+            job = pool.tubes.reserve
 
           rescue Exception => ex
 

data/spec/ayl_worker_control_spec.rb

@@ -13,14 +13,14 @@ describe 'ayl_worker_control script' do
 
     it "should honor the use of the -a option to name the daemon" do
       ARGV.concat [ '--', '--pid-path', '/tmp', '--name', 'the_name' ]
-      Daemons.should_receive(:run).with(anything, { :log_dir => '/tmp', :log_output => true, :dir_mode => :normal, :dir => '/tmp', :multiple => true, :app_name => 'the_name' })
+      expect(Daemons).to receive(:run).with(anything, { :log_dir => '/tmp', :log_output => true, :dir_mode => :normal, :dir => '/tmp', :multiple => true, :app_name => 'the_name' })
 
       load(@ayl_control_script, true)
     end
 
     it "should assume the use of the script for the daemon name if no name argument is specified" do
       ARGV.concat [ '--', '--pid-path', '/tmp' ]
-      Daemons.should_receive(:run).with(anything, { :log_dir => '/tmp', :log_output => true, :dir_mode => :normal, :dir => '/tmp', :multiple => true })
+      expect(Daemons).to receive(:run).with(anything, { :log_dir => '/tmp', :log_output => true, :dir_mode => :normal, :dir => '/tmp', :multiple => true })
 
       load(@ayl_control_script, true)
     end

data/spec/ayl_worker_spec.rb

@@ -13,34 +13,34 @@ describe "ayl_worker script" do
 
     it "requires that an application path be specified" do
       Object.any_instance.stub(:puts)
-      lambda { load(@ayl_script, true) }.should exit_with_code(64)
+      expect { load(@ayl_script, true) }.to exit_with_code(64)
     end
 
     it "should exit with a status code of 0 if help is invoked" do
       ARGV << '--help'
       Ayl::CommandLine.stub(:puts)
-      lambda { load(@ayl_script, true) }.should exit_with_code(0)
+      expect { load(@ayl_script, true) }.to exit_with_code(0)
     end
 
     it "should exit when an invalid argument is specified" do
       ARGV << '--not-real'
 
-      lambda { load(@ayl_script, true) }.should raise_error(OptionParser::InvalidOption)
+      expect { load(@ayl_script, true) }.to raise_error(OptionParser::InvalidOption)
     end
 
     it "should set the correct tube name when specified on the command line" do
       ARGV.concat [ "-a", "support", "-t", "the-tube" ]
       
-      Ayl::MessageOptions.should_receive(:default_queue_name=).with('the-tube')
+      expect(Ayl::MessageOptions).to receive(:default_queue_name=).with('the-tube')
 
-      mock_worker = mock("Worker")
-      mock_worker.should_receive(:process_messages)
-      mock_worker.should_receive(:eval_binding=)
+      mock_worker = double("Worker")
+      expect(mock_worker).to receive(:process_messages)
+      expect(mock_worker).to receive(:eval_binding=)
 
-      mock_active_engine = mock("ActiveEngine")
-      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+      mock_active_engine = double("ActiveEngine")
+      expect(mock_active_engine).to receive(:worker).and_return(mock_worker)
 
-      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
+      expect(Ayl::Engine).to receive(:get_active_engine).and_return(mock_active_engine)
 
       load(@ayl_script, true)
     end
@@ -48,16 +48,16 @@ describe "ayl_worker script" do
     it "should set the default tube name when not specified on the command line" do
       ARGV.concat [ "-a", "support" ]
       
-      Ayl::MessageOptions.should_receive(:default_queue_name=).with('default')
+      expect(Ayl::MessageOptions).to receive(:default_queue_name=).with('default')
 
-      mock_worker = mock("Worker")
-      mock_worker.should_receive(:process_messages)
-      mock_worker.should_receive(:eval_binding=)
+      mock_worker = double("Worker")
+      expect(mock_worker).to receive(:process_messages)
+      expect(mock_worker).to receive(:eval_binding=)
 
-      mock_active_engine = mock("ActiveEngine")
-      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+      mock_active_engine = double("ActiveEngine")
+      expect(mock_active_engine).to receive(:worker).and_return(mock_worker)
 
-      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
+      expect(Ayl::Engine).to receive(:get_active_engine).and_return(mock_active_engine)
 
       load(@ayl_script, true)
     end
@@ -65,17 +65,17 @@ describe "ayl_worker script" do
     it "should default to a rails production environment if not specified" do
       ARGV.concat [ "-a", "support", "-r" ]
 
-      Ayl::MessageOptions.should_receive(:default_queue_name=).with('default')
+      expect(Ayl::MessageOptions).to receive(:default_queue_name=).with('default')
 
-      mock_worker = mock("Worker")
-      mock_worker.should_receive(:process_messages)
-      mock_worker.should_receive(:eval_binding=)
+      mock_worker = double("Worker")
+      expect(mock_worker).to receive(:process_messages)
+      expect(mock_worker).to receive(:eval_binding=)
 
-      mock_active_engine = mock("ActiveEngine")
-      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+      mock_active_engine = double("ActiveEngine")
+      expect(mock_active_engine).to receive(:worker).and_return(mock_worker)
 
-      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
-      ENV.should_receive(:[]=).with('RAILS_ENV', 'production')
+      expect(Ayl::Engine).to receive(:get_active_engine).and_return(mock_active_engine)
+      expect(ENV).to receive(:[]=).with('RAILS_ENV', 'production')
 
       load(@ayl_script, true)
     end
@@ -83,17 +83,17 @@ describe "ayl_worker script" do
     it "should use the specified rails environment" do
       ARGV.concat [ "-a", "support", "-r", "-e", "development" ]
 
-      Ayl::MessageOptions.should_receive(:default_queue_name=).with('default')
+      expect(Ayl::MessageOptions).to receive(:default_queue_name=).with('default')
 
-      mock_worker = mock("Worker")
-      mock_worker.should_receive(:process_messages)
-      mock_worker.should_receive(:eval_binding=)
+      mock_worker = double("Worker")
+      expect(mock_worker).to receive(:process_messages)
+      expect(mock_worker).to receive(:eval_binding=)
 
-      mock_active_engine = mock("ActiveEngine")
-      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+      mock_active_engine = double("ActiveEngine")
+      expect(mock_active_engine).to receive(:worker).and_return(mock_worker)
 
-      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
-      ENV.should_receive(:[]=).with('RAILS_ENV', 'development')
+      expect(Ayl::Engine).to receive(:get_active_engine).and_return(mock_active_engine)
+      expect(ENV).to receive(:[]=).with('RAILS_ENV', 'development')
 
       load(@ayl_script, true)
     end

data/spec/command_line_spec.rb

@@ -10,12 +10,12 @@ describe Ayl::CommandLine do
       
       app_arguments = %w{ -a path-to-app -r -e development }
 
-      Ayl::CommandLine.grab_app_arguments(raw_argv).should == app_arguments
+      expect(Ayl::CommandLine.grab_app_arguments(raw_argv)).to eq(app_arguments)
     end
 
     it "raise an exception if no application marker exists in the command line arguments" do
       raw_argv = %w{ start -a path-to-app -r -e development }
-      lambda { Ayl::CommandLine.grab_app_arguments(raw_argv) }.should raise_exception
+      expect { Ayl::CommandLine.grab_app_arguments(raw_argv) }.to raise_exception
     end
 
   end
@@ -25,18 +25,18 @@ describe Ayl::CommandLine do
     it "should extract the correct options from the command line when the short options are used" do
       argv = %w{ -t tube_name -e development -a app_path -r -c config/environment -p pid_path -n the_name }
       parsed_options = Ayl::CommandLine.parse!(argv)
-      parsed_options.should == { :tube => 'tube_name', :env => 'development', :app_path => 'app_path', :rails_app => true, :app_require => 'config/environment', :pid_path => 'pid_path', :app_name => 'the_name' }
+      expect(parsed_options).to eq({ :tube => 'tube_name', :env => 'development', :app_path => 'app_path', :rails_app => true, :app_require => 'config/environment', :pid_path => 'pid_path', :app_name => 'the_name' })
     end
 
     it "should extract the correct options from the command line when the long options are used" do
       argv = %w{ --tube tube_name --environment development --app-path app_path --rails --require config/environment --pid-path pid_path --name the_name }
       parsed_options = Ayl::CommandLine.parse!(argv)
-      parsed_options.should == { :tube => 'tube_name', :env => 'development', :app_path => 'app_path', :rails_app => true, :app_require => 'config/environment', :pid_path => 'pid_path', :app_name => 'the_name' }
+      expect(parsed_options).to eq({ :tube => 'tube_name', :env => 'development', :app_path => 'app_path', :rails_app => true, :app_require => 'config/environment', :pid_path => 'pid_path', :app_name => 'the_name' })
     end
 
     it "should raise an exception if invalid arguments are provided" do
       argv = %w{ --tuber tube_name --environmen development --apppath app_path --rail --require config/environment --pidpath pid_path }
-      lambda { Ayl::CommandLine.parse!(argv) }.should raise_exception
+      expect { Ayl::CommandLine.parse!(argv) }.to raise_exception
     end
 
   end

data/spec/engine_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'beanstalk-client'
 require 'active_record'
 require 'active_record/errors'
 
@@ -16,26 +15,26 @@ describe Ayl::Beanstalk::Engine do
     end
 
     it "should default to localhost and 11300 as the host port for the beanstalkd server" do
-      @engine.host.should == 'localhost'
-      @engine.port.should == 11300
+      expect(@engine.host).to eq('localhost')
+      expect(@engine.port).to eq(11300)
     end
 
     it "should respond true to the asynchronous? message" do
-      @engine.asynchronous?.should be_true
+      expect(@engine.asynchronous?).to be true
     end
 
     it "should return true if it has a valid connection to beanstalk" do
-      mock_pool = mock("Beanstalk::Pool")
+      mock_pool = double("Beanstalk::Pool")
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      expect(Beaneater).to receive(:new).with("localhost:11300").and_return(mock_pool)
 
-      @engine.is_connected?.should be_true
+      expect(@engine.is_connected?).to be true
     end
 
     it "should return false if it does not have a valid connection to beanstalk" do
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_raise(::Beanstalk::NotConnected)
+      expect(Beaneater).to receive(:new).with("localhost:11300").and_raise(Beaneater::NotConnected)
 
-      @engine.is_connected?.should be_false
+      expect(@engine.is_connected?).to be false
     end
 
     context "Message Submission" do
@@ -45,11 +44,14 @@ describe Ayl::Beanstalk::Engine do
       end
 
       it "should submit the specified message to beanstalk" do
-        mock_pool = mock("Beanstalk::Pool")
-        mock_pool.should_receive(:use).with("default")
-        mock_pool.should_receive(:yput).with( { :type => :ayl, :failed_job_handler => 'delete', :code => "23.to_s(2)" }, 512, 0, 120)
-
-        ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+        mock_tube = double("Tube")
+        expect(mock_tube).to receive(:put).
+          with({ :type => :ayl, :failed_job_handler => 'delete', :code => "23.to_s(2)" }.to_json, {
+          pri: 512, delay: 0, ttr: 120})
+        mock_pool = double("Beanstalk::Pool")
+        expect(mock_pool).to receive(:tubes).and_return({'default' => mock_tube})
+
+        expect(Beaneater).to receive(:new).with("localhost:11300").and_return(mock_pool)
 
         @engine.submit(@msg)
       end

data/spec/job_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
-require 'beanstalk-client'
 
-describe Beanstalk::Job do
+describe Beaneater::Job do
   
   before(:each) do
-    @job = Beanstalk::Job.new(nil,nil,nil)
+    @job = Beaneater::Job.new(nil,{id: '1', body: '{"ayl":"thing"}', status: 'RESERVED'})
     @job.stub_chain(:logger, :error)
     @job.stub_chain(:logger, :debug)
   end
@@ -12,36 +11,32 @@ describe Beanstalk::Job do
   context '#ayl_message' do
 
     it "should return the message constructed from the body of the job" do
-      @job.stub(:ybody).and_return('the body')
       msg = Ayl::Message.new(nil,nil,nil)
-      Ayl::Message.should_receive(:from_hash).with('the body').and_return(msg)
+      expect(Ayl::Message).to receive(:from_hash).with({"ayl"=>"thing"}).and_return(msg)
 
-      @job.ayl_message.should == msg
+      expect(@job.ayl_message).to eq(msg)
     end
 
     it "should return the same message constructed from the body of the job on subsequent calls" do
-      @job.stub(:ybody).and_return('the body')
       msg = Ayl::Message.new(nil,nil,nil)
-      Ayl::Message.should_receive(:from_hash).with('the body').and_return(msg)
+      expect(Ayl::Message).to receive(:from_hash).with({"ayl"=>"thing"}).and_return(msg)
 
-      @job.ayl_message.should == msg
+      expect(@job.ayl_message).to eq(msg)
 
-      @job.ayl_message.should == msg
+      expect(@job.ayl_message).to eq(msg)
     end
 
     it "should return nil and send an email if the message body was bad" do
-      @job.stub(:ybody).and_return('the body')
       msg = Ayl::Message.new(nil,nil,nil)
       ex = Ayl::UnrecoverableMessageException.new
-      Ayl::Message.should_receive(:from_hash).with('the body').and_raise(ex)
+      expect(Ayl::Message).to receive(:from_hash).with({"ayl"=>"thing"}).and_raise(ex)
 
-      Ayl::Mailer.should_receive(:instance).and_return do 
-        mock("Mailer").tap do | mock_mailer |
-          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
-        end
-      end
+      mock_mailer = double("Mailer")
+      expect(mock_mailer).to receive(:deliver_message).with(anything(), ex)
 
-      @job.ayl_message.should == nil
+      expect(Ayl::Mailer).to receive(:instance).and_return(mock_mailer)
+
+      expect(@job.ayl_message).to be_nil
     end
 
   end
@@ -49,20 +44,19 @@ describe Beanstalk::Job do
   context '#ayl_delete' do
 
     it "should call the delete method on the job" do
-      @job.should_receive(:delete)
+      expect(@job).to receive(:delete)
 
       @job.ayl_delete
     end
 
     it "should send an email if the delete method raises an exception" do
       ex = Exception.new
-      @job.should_receive(:delete).and_raise(ex)
+      expect(@job).to receive(:delete).and_raise(ex)
+
+      mock_mailer = double("Mailer")
+      expect(mock_mailer).to receive(:deliver_message).with(anything(), ex)
 
-      Ayl::Mailer.should_receive(:instance).and_return do 
-        mock("Mailer").tap do | mock_mailer |
-          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
-        end
-      end
+      expect(Ayl::Mailer).to receive(:instance).and_return(mock_mailer) 
 
       @job.ayl_delete
     end
@@ -72,32 +66,31 @@ describe Beanstalk::Job do
   context '#ayl_decay' do
 
     it "should call the decay with no arguments when nil delay is specified" do
-      @job.should_receive(:decay).with()
+      expect(@job).to receive(:release).with({})
 
       @job.ayl_decay(nil)
     end
 
     it "should call the decay with no arguments when no delay is specified" do
-      @job.should_receive(:decay).with()
+      expect(@job).to receive(:release).with({})
 
       @job.ayl_decay
     end
 
     it "should call the decay with no arguments when no delay is specified" do
-      @job.should_receive(:decay).with(10)
+      expect(@job).to receive(:release).with({delay: 10})
 
       @job.ayl_decay(10)
     end
 
     it "should send an email if the decay method raises an exception" do
       ex = Exception.new
-      @job.should_receive(:decay).and_raise(ex)
+      expect(@job).to receive(:release).and_raise(ex)
+
+      mock_mailer = double("Mailer")
+      expect(mock_mailer).to receive(:deliver_message).with(anything(), ex)
 
-      Ayl::Mailer.should_receive(:instance).and_return do 
-        mock("Mailer").tap do | mock_mailer |
-          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
-        end
-      end
+      expect(Ayl::Mailer).to receive(:instance).and_return(mock_mailer)
 
       @job.ayl_decay
     end
@@ -107,20 +100,19 @@ describe Beanstalk::Job do
   context '#ayl_bury' do
 
     it "should call the bury method on the job" do
-      @job.should_receive(:bury)
+      expect(@job).to receive(:bury)
 
       @job.ayl_bury
     end
 
     it "should send an email if the bury method raises an exception" do
       ex = Exception.new
-      @job.should_receive(:bury).and_raise(ex)
+      expect(@job).to receive(:bury).and_raise(ex)
 
-      Ayl::Mailer.should_receive(:instance).and_return do 
-        mock("Mailer").tap do | mock_mailer |
-          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
-        end
-      end
+      mock_mailer = double("Mailer")
+      expect(mock_mailer).to receive(:deliver_message).with(anything(), ex)
+
+      expect(Ayl::Mailer).to receive(:instance).and_return(mock_mailer)
 
       @job.ayl_bury
     end
@@ -129,37 +121,39 @@ describe Beanstalk::Job do
 
   context '#handle_decay' do
 
-    it "should decay the job if the age of the job is less than 60 seconds" do
-      @job.should_receive(:age).at_least(1).times.and_return(2)
-      @job.should_receive(:ayl_decay)
-      
-      ex = Exception.new
+    it "should decay the job if the number of times the job has been reserved is less than the configured failed job count" do
+      mock_options = double("options")
+      expect(mock_options).to receive(:failed_job_count).and_return(2)
+      expect(mock_options).to receive(:failed_job_delay).and_return(3)
 
-      @job.handle_decay(ex)
-    end
+      mock_message = double("message")
+      expect(mock_message).to receive(:options).exactly(2).times.and_return(mock_options)
 
-    it "should decay the job if the age of the job is exactly 60 seconds" do
-      @job.should_receive(:age).at_least(1).times.and_return(60)
-      @job.should_receive(:ayl_decay)
-      
-      ex = Exception.new
+      expect(@job).to receive(:reserves).and_return(1)
+      expect(@job).to receive(:ayl_message).exactly(2).times.and_return(mock_message)
+      expect(@job).to receive(:ayl_decay).with(3)
 
-      @job.handle_decay(ex)
+      @job.handle_decay(Exception.new)
     end
 
-    it "should delete the job and send an email if the job was older than 60 seconds" do
-      @job.should_receive(:age).at_least(1).times.and_return(61)
-      @job.should_receive(:ayl_delete)
-      
-      ex = Exception.new
+    it "should bury the job if the number of times the job has been reserved is the same or more than the configured failed job count" do
+      mock_options = double("options")
+      expect(mock_options).to receive(:failed_job_count).and_return(2)
+
+      mock_message = double("message")
+      expect(mock_message).to receive(:options).and_return(mock_options)
+      expect(mock_message).to receive(:code).and_return('the code')
+
+      expect(@job).to receive(:reserves).and_return(2)
+      expect(@job).to receive(:ayl_message).exactly(2).times.and_return(mock_message)
+      expect(@job).to receive(:ayl_bury)
+
+      mock_mailer = double('Ayl::Mailer')
+      expect(mock_mailer).to receive(:burying_job).with('the code')
 
-      Ayl::Mailer.should_receive(:instance).and_return do 
-        mock("Mailer").tap do | mock_mailer |
-          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
-        end
-      end
+      expect(Ayl::Mailer).to receive(:instance).and_return(mock_mailer)
 
-      @job.handle_decay(ex)
+      @job.handle_decay(Exception.new)
     end
 
   end