quebert 3.0.3 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 107451b4a0b3a15d3e42285f65c1c53be6700c52
-  data.tar.gz: ce2f9fd96496d6701eadad9abd94acc33a7fa6d4
+  metadata.gz: baaa9b7110f75a9e262655df715e382e9ed077ef
+  data.tar.gz: e7a853977371a583075d20f49b4ff3d60d8a3b46
 SHA512:
-  metadata.gz: 06fe749f66920ee7ebb436b72d82c3d0f2f68049cf5dfbba10c9ca3e7ac76eebfb60644cab07634d23fb9d8863b9b5c16880c45b3191f91a6ee187604fc2adea
-  data.tar.gz: 3523257233d8d1f7732be791ae48a6bb7f359ba063231908c4c5957e9411333b48ea32ecd70daec03a0dd915847b087abf4247f21b33c78fadab3575e44e5b84
+  metadata.gz: 4c1f3b987b48dcdd55440807402135e07c29f918a2912fbc5996121c81508b083db251d558d40491ea3a09452c63b6e799f04cff1879afd7bc2404dacaed0587
+  data.tar.gz: 38afc9cb326c59c5da71fb1d96396c3aac0eb4cc889d2e5288b8673792f7150b33a705bf7dea45cc0828246b54b669516f8dcefae78d2d30e35329d62b45c58b

data/.ruby-version

@@ -1 +1 @@
-2.2.5
+2.4.1

data/.travis.yml

@@ -1,6 +1,8 @@
 language: ruby
 rvm:
   - 2.2.5
+  - 2.3.1
+  - 2.4.1
 before_install:
   - curl -L https://github.com/kr/beanstalkd/archive/v1.9.tar.gz | tar xz -C /tmp
   - cd /tmp/beanstalkd-1.9/

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## 3.2.0
+
+* Add support for Beanstalk event hooks (#22)
+
+## 3.1.0
+
+* Add support for Ruby 2.4.1
+
+## 3.0.0
+
+* Add support for multiple tubes
+* Allow params like ttr to be changed per job

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 group :test do
   gem 'activerecord', '~> 4.0'
   gem 'sqlite3-ruby'
-  gem 'guard-rspec'
+  gem 'rspec', '~> 3.5'
   gem 'rb-fsevent'
+  gem 'pry'
 end

data/README.md

@@ -33,6 +33,11 @@ Some features that are currently *missing* that I will soon add include:
 
 There are two ways to enqueue jobs with Quebert: through the Job itself, provided you set a default back-end for the job, or put it on the backend.
 
+### Supported Ruby Versions
+
+Quebert officially is supported to run on the currently supported versions of MRI.
+This includes versions >= `2.2.5`. Have a look at the `.travis.yml` configuration file to see all Ruby versions we support.
+
 ### Jobs
 
 Quebert includes a Job class so you can implement how you want certain types of Jobs performed.
@@ -91,7 +96,7 @@ Quebert.config.from_hash(Rails.application.config.quebert)
 Quebert.config.logger = Rails.logger
 ```
 
-### Job & Worker hooks
+### Global Job hooks
 
 Quebert has support for providing custom hooks to be called before, after & around your jobs are being run.
 A common example is making sure that any active ActiveRecord database connections are put back on the connection pool after a job is done:
@@ -112,6 +117,22 @@ Quebert.config.around_job do |job|
 end
 ```
 
+### Beanstalk Job hooks
+
+Jobs can define their own business logic that will get called surrounding Beanstalk events:
+
+```ruby
+class FooJob < Quebert::Job
+  def around_bury
+    # custom pre-bury code
+    yield
+    # custom post-bury code
+  end
+end
+```
+
+Supported Beanstalk event hooks: `around_bury`, `around_release`, `around_delete`
+
 ### Async sender
 
 Take any ol' class and include the Quebert::AsyncSender.

data/lib/quebert/async_sender/instance.rb

@@ -19,6 +19,8 @@ module Quebert
         base.instance_eval do
           def method_added(name)
             return if name != :initialize
+            return if @__initialize_overwritten__
+            @__initialize_overwritten__ = true
             overwrite_initialize
           end
         end

data/lib/quebert/controller/beanstalk.rb

@@ -28,22 +28,22 @@ module Quebert
         result = false
         time = Benchmark.realtime do
           result = job.perform!
-          beanstalk_job.delete
+          delete
         end
 
         logger.info(job) { "Completed in #{(time*1000*1000).to_i/1000.to_f} ms\n" }
         result
       rescue Job::Delete
         logger.info(job) { "Deleting job" }
-        beanstalk_job.delete
+        delete
         logger.info(job) { "Job deleted" }
       rescue Job::Release
         logger.info(job) { "Releasing with priority: #{job.priority} and delay: #{job.delay}" }
-        beanstalk_job.release :pri => job.priority, :delay => job.delay
+        release(pri: job.priority, delay: job.delay)
         logger.info(job) { "Job released" }
       rescue Job::Bury
         logger.info(job) { "Burying job" }
-        beanstalk_job.bury
+        bury
         logger.info(job) { "Job buried" }
       rescue Job::Timeout => e
         logger.info(job) { "Job timed out. Retrying with delay. #{e.inspect} #{e.backtrace.join("\n")}" }
@@ -56,7 +56,7 @@ module Quebert
         retry_with_delay
       rescue => e
         logger.error(job) { "Error caught on perform. Burying job. #{e.inspect} #{e.backtrace.join("\n")}" }
-        beanstalk_job.bury
+        bury
         logger.error(job) { "Job buried" }
         raise
       end
@@ -67,11 +67,11 @@ module Quebert
 
         if delay > MAX_TIMEOUT_RETRY_DELAY
           logger.error(job) { "Max retry delay exceeded. Burying job" }
-          beanstalk_job.bury
+          bury
           logger.error(job) { "Job buried" }
         else
           logger.error(job) { "TTR exceeded. Releasing with priority: #{job.priority} and delay: #{delay}" }
-          beanstalk_job.release :pri => job.priority, :delay => delay
+          release(pri: job.priority, delay: delay)
           logger.error(job) { "Job released" }
         end
       rescue ::Beaneater::NotFoundError
@@ -79,6 +79,24 @@ module Quebert
         # Sometimes the timer doesn't behave correctly and this job actually runs longer than
         # allowed. At that point the beanstalk job no longer exists anymore. Lets let it go and don't blow up.
       end
+
+      def bury
+        job.around_bury do
+          beanstalk_job.bury
+        end
+      end
+
+      def release(opts)
+        job.around_release do
+          beanstalk_job.release(opts)
+        end
+      end
+
+      def delete
+        job.around_delete do
+          beanstalk_job.delete
+        end
+      end
     end
   end
 end

data/lib/quebert/job.rb

@@ -89,6 +89,21 @@ module Quebert
       @backend || Quebert.configuration.backend
     end
 
+    # Event hook that can be overridden
+    def around_bury
+      yield
+    end
+
+    # Event hook that can be overridden
+    def around_release
+      yield
+    end
+
+    # Event hook that can be overridden
+    def around_delete
+      yield
+    end
+
   protected
     def delete!
       raise Delete

data/lib/quebert/version.rb

@@ -1,3 +1,3 @@
 module Quebert
-  VERSION = "3.0.3"
+  VERSION = "3.2.0"
 end

data/spec/async_sender_spec.rb

@@ -36,34 +36,34 @@ describe AsyncSender::Class do
   describe "#async_send" do
     it "should async send class methods" do
       Greeter.async_send(:hi, 'Jeannette')
-      @q.reserve.perform.should eql(Greeter.send(:hi, 'Jeannette'))
+      expect(@q.reserve.perform).to eql(Greeter.send(:hi, 'Jeannette'))
     end
     
     it "should async send instance methods" do
       Greeter.new("brad").async_send(:hi, 'stunning')
-      @q.reserve.perform.should eql(Greeter.new("brad").hi('stunning'))
+      expect(@q.reserve.perform).to eql(Greeter.new("brad").hi('stunning'))
     end
   end
 
   describe "#async() promise" do
     it "should async send class methods" do
       Greeter.async.hi('Jeannette')
-      @q.reserve.perform.should eql(Greeter.send(:hi, 'Jeannette'))
+      expect(@q.reserve.perform).to eql(Greeter.send(:hi, 'Jeannette'))
     end
     
     it "should async send instance methods" do
       Greeter.new("brad").async.hi('stunning')
-      @q.reserve.perform.should eql(Greeter.new("brad").hi('stunning'))
+      expect(@q.reserve.perform).to eql(Greeter.new("brad").hi('stunning'))
     end
 
     it "should async send private instance methods" do
       Greeter.new("brad").async.send(:bye, 'stunning')
-      @q.reserve.perform.should eql(Greeter.new("brad").send(:bye, 'stunning'))
+      expect(@q.reserve.perform).to eql(Greeter.new("brad").send(:bye, 'stunning'))
     end
 
     it "should async send private class methods" do
       Greeter.async.send(:bye, 'Jeannette')
-      @q.reserve.perform.should eql(Greeter.send(:bye, 'Jeannette'))
+      expect(@q.reserve.perform).to eql(Greeter.send(:bye, 'Jeannette'))
     end
   end
 end
@@ -89,7 +89,7 @@ describe AsyncSender::ActiveRecord do
     
     it "should async_send instance method" do
       User.first.async_send(:name)
-      @q.reserve.perform.should eql(User.first.name)
+      expect(@q.reserve.perform).to eql(User.first.name)
     end
   end
   
@@ -101,20 +101,20 @@ describe AsyncSender::ActiveRecord do
         u.send(:write_attribute, :last_name, "Jones")
       end
       user.async.name
-      @q.reserve.perform.should eql("Barf Jones")
+      expect(@q.reserve.perform).to eql("Barf Jones")
     end
   end
   
   it "should async class method" do
     email = "brad@bradgessler.com"
     User.async.emailizer(email)
-    @q.reserve.perform.should eql(email)
+    expect(@q.reserve.perform).to eql(email)
   end
   
   it "should async_send and successfully serialize param object" do
     user = User.new(:first_name => 'Brad')
     user2 = User.new(:first_name => 'Steel')
     user.async.email!(user2)
-    @q.reserve.perform.first_name.should eql('Steel')
+    expect(@q.reserve.perform.first_name).to eql('Steel')
   end
 end

data/spec/backend_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
 describe Backend do
-  it "should have register backends" do
-    Quebert.backends.keys.should =~ [:in_process, :beanstalk, :sync]
+  it "has register backends" do
+    expect(Quebert.backends.keys).to match_array([:in_process, :beanstalk, :sync])
   end
 
-  it "should register backends" do
+  it "registers backends" do
     Quebert.backends.register :twenty, 20
-    Quebert.backends[:twenty].should eql(20)
+    expect(Quebert.backends[:twenty]).to eql(20)
   end
 
-  it "should unregister backends" do
+  it "unregisters backends" do
     Quebert.backends.unregister :twenty
-    Quebert.backends[:twenty].should be_nil
+    expect(Quebert.backends[:twenty]).to be_nil
   end
 end
 
@@ -21,15 +21,15 @@ describe Backend::InProcess do
     @q = Backend::InProcess.new
   end
 
-  it "should put on queue" do
+  it "puts on queue" do
     3.times do |num|
       @q.put Adder.new(num)
     end
   end
 
-  it "should consume from queue" do
+  it "consumes from queue" do
     3.times do |num|
-      @q.reserve.perform.should eql(num)
+      expect(@q.reserve.perform).to eql(num)
     end
   end
 end
@@ -40,19 +40,19 @@ describe Backend::Beanstalk  do
     @q.drain!
   end
 
-  it "should put on queue" do
+  it "puts on queue" do
     3.times do |num|
       @q.put Adder.new(num)
     end
   end
 
-  it "should consume from queue" do
+  it "consumes from queue" do
     3.times do |num|
-      @q.reserve.perform.should eql(num)
+      expect(@q.reserve.perform).to eql(num)
     end
   end
 
-  it "should consume from multiple queues" do
+  it "consumes from multiple queues" do
     @q.queues = ["a", "b"]
     job1 = Adder.new(1)
     job1.queue = "a"
@@ -60,8 +60,8 @@ describe Backend::Beanstalk  do
     job2 = Adder.new(2)
     job2.queue = "b"
     @q.put(job2)
-    @q.reserve.perform.should eql(1)
-    @q.reserve.perform.should eql(2)
+    expect(@q.reserve.perform).to eql(1)
+    expect(@q.reserve.perform).to eql(2)
   end
 end
 
@@ -70,15 +70,15 @@ describe Backend::Sync do
     @q = Backend::Sync.new
   end
 
-  it "should put on queue" do
+  it "puts on queue" do
     3.times do |num|
-      @q.put(Adder.new(num)).should eql(num)
+      expect(@q.put(Adder.new(num))).to eql(num)
     end
   end
 
-  it "should do nothing when consuming from queue" do
+  it "does nothing when consuming from queue" do
     3.times do |num|
-      @q.reserve.perform.should be_nil
+      expect(@q.reserve.perform).to be_nil
     end
   end
 end

data/spec/command_line_runner_spec.rb

@@ -4,74 +4,74 @@ describe CommandLineRunner do
   before(:all) do
     Quebert.config.backend = Backend::InProcess.new
   end
-  
+
   context "log-file" do
-    it "should write log file" do
+    it "writes log file" do
       clean_file 'log.log' do
-        lambda{
+        expect {
           CommandLineRunner.dispatch(%w(worker --log log.log))
-        }.should change { File.read('log.log') if File.exists?('log.log') }
+        }.to change { File.read('log.log') if File.exists?('log.log') }
       end
     end
   end
-  
+
   context "pid-file" do
-    it "should write pid" do
+    it "writes pid" do
       clean_file 'pid.pid' do
-        File.exists?('pid').should be_false
+        expect(File.exists?('pid')).to be_falsey
         CommandLineRunner.dispatch(%w(worker --pid pid.pid))
-        Support::PidFile.read('pid.pid').should eql(Process.pid)
+        expect(Support::PidFile.read('pid.pid')).to eql(Process.pid)
       end
     end
-    
-    it "should remove stale" do
+
+    it "removes stale" do
       clean_file 'pid.pid', "-1" do
         CommandLineRunner.dispatch(%w(worker --pid pid.pid))
-        Support::PidFile.read('pid.pid').should eql(Process.pid)
+        expect(Support::PidFile.read('pid.pid')).to eql(Process.pid)
       end
     end
-    
-    it "should complain if the pid is already running" do
+
+    it "complains if the pid is already running" do
       clean_file 'pid.pid', Process.pid do
-        lambda{
+        expect {
           CommandLineRunner.dispatch(%w(worker --pid pid.pid))
-        }.should raise_exception(Support::PidFile::ProcessRunning)
-        Support::PidFile.read('pid.pid').should eql(Process.pid)
+        }.to raise_exception(Support::PidFile::ProcessRunning)
+        expect(Support::PidFile.read('pid.pid')).to eql(Process.pid)
       end
     end
   end
-  
+
   context "config-file" do
-    it "should auto-detect rails environment file" do
+    it "auto-detects rails environment file" do
       clean_file './config/environment.rb', "raise 'RailsConfig'" do
-        lambda{
+        expect {
           CommandLineRunner.dispatch(%w(worker))
-        }.should raise_exception('RailsConfig')
+        }.to raise_exception('RailsConfig')
       end
     end
-    
-    it "should run config file" do
+
+    it "runs config file" do
       clean_file './super_awesome.rb', "raise 'SuperAwesome'" do
-        lambda{
+        expect {
           CommandLineRunner.dispatch(%w(worker --config ./super_awesome.rb))
-        }.should raise_exception('SuperAwesome')
+        }.to raise_exception('SuperAwesome')
       end
     end
-    
+
   end
-  
+
   context "chdir" do
     before(:each) do
       @chdir = Dir.pwd
     end
-    
-    it "should change chdir" do
+
+    it "changes chdir" do
       CommandLineRunner.dispatch(%w(worker --chdir /))
-      Dir.pwd.should eql('/')
+      expect(Dir.pwd).to eql('/')
     end
-    
+
     after(:each) do
       Dir.chdir(@chdir)
     end
   end
-end
+end

data/spec/configuration_spec.rb

@@ -11,11 +11,11 @@ describe Configuration do
 
     it "should configure backend" do
       backend = @config.backend
-      backend.should be_instance_of(Quebert::Backend::Beanstalk)
+      expect(backend).to be_instance_of(Quebert::Backend::Beanstalk)
       # Blech, gross nastiness in their lib, but we need to look in to see if this stuff as configed
-      backend.send(:beanstalkd_connection).connection.host.should eql("localhost")
-      backend.send(:beanstalkd_connection).connection.port.should eql(11300)
-      backend.send(:default_tube).name.should eql("quebert-config-test")
+      expect(backend.send(:beanstalkd_connection).connection.host).to eql("localhost")
+      expect(backend.send(:beanstalkd_connection).connection.port).to eql(11300)
+      expect(backend.send(:default_tube).name).to eql("quebert-config-test")
     end
   end
 end

data/spec/consumer_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
 
 describe Controller::Base do
-  it "should perform job" do
-    Controller::Base.new(Adder.new(1,2)).perform.should eql(3)
+  it "performs a job" do
+    expect(
+      Controller::Base.new(Adder.new(1,2)).perform
+    ).to eql(3)
   end
 
-  it "should rescue all raised job actions" do
+  it "rescues all raised job actions" do
     [ReleaseJob, DeleteJob, BuryJob].each do |job|
-      lambda{
+      expect {
         Controller::Base.new(job.new).perform
-      }.should_not raise_exception
+      }.to_not raise_exception
     end
   end
 end
@@ -24,76 +26,80 @@ describe Controller::Beanstalk do
     @q.drain!
   end
 
-  it "should delete job off queue after succesful run" do
+  it "deletes job off queue after succesful run" do
     @q.put Adder.new(1, 2)
-    @q.peek(:ready).should_not be_nil
-    @q.reserve.perform.should eql(3)
-    @q.peek(:ready).should be_nil
+    expect(@q.peek(:ready)).to_not be_nil
+    expect(@q.reserve.perform).to eql(3)
+    expect(@q.peek(:ready)).to be_nil
   end
 
-  it "should bury job if an exception occurs in job" do
+  it "buries job if an exception occurs in job" do
     @q.put Exceptional.new
-    @q.peek(:ready).should_not be_nil
-    lambda{ @q.reserve.perform }.should raise_exception
-    @q.peek(:buried).should_not be_nil
+    expect(@q.peek(:ready)).to_not be_nil
+    expect { @q.reserve.perform }.to raise_exception(RuntimeError, "Exceptional")
+    expect(@q.peek(:buried)).to_not be_nil
   end
 
-  it "should bury an AR job if an exception occurs deserializing it" do
+  it "buries an AR job if an exception occurs deserializing it" do
     tube = @q.send(:default_tube)
     tube.put({:foo => "bar"}.to_json)
-    tube.peek(:ready).should_not be_nil
-    lambda{ @q.reserve.perform }.should raise_exception
-    tube.peek(:buried).should_not be_nil
+    expect(tube.peek(:ready)).to_not be_nil
+    expect { @q.reserve.perform }.to raise_exception(NoMethodError)
+    expect(tube.peek(:buried)).to_not be_nil
   end
 
   context "job actions" do
-    it "should delete job" do
+    it "deletes a job" do
       @q.put DeleteJob.new
-      @q.peek(:ready).should_not be_nil
+      expect(@q.peek(:ready)).to_not be_nil
       @q.reserve.perform
-      @q.peek(:ready).should be_nil
+      expect(@q.peek(:ready)).to be_nil
     end
 
-    it "should release job" do
+    it "releases a job" do
       @q.put ReleaseJob.new
-      @q.peek(:ready).should_not be_nil
+      expect(@q.peek(:ready)).to_not be_nil
       @q.reserve.perform
-      @q.peek(:ready).should_not be_nil
+      expect(@q.peek(:ready)).to_not be_nil
     end
 
-    it "should bury job" do
+    it "buries a job" do
       @q.put BuryJob.new
-      @q.peek(:ready).should_not be_nil
-      @q.peek(:buried).should be_nil
+      expect(@q.peek(:ready)).to_not be_nil
+      expect(@q.peek(:buried)).to be_nil
       @q.reserve.perform
-      @q.peek(:ready).should be_nil
-      @q.peek(:buried).should_not be_nil
+      expect(@q.peek(:ready)).to be_nil
+      expect(@q.peek(:buried)).to_not be_nil
     end
   end
 
-  it "should retry a job with a delay and then bury" do
+  it "retries a job with a delay and then buries it" do
     TimeoutJob.backend = @q
     TimeoutJob.new.enqueue
-    @q.peek(:ready).should_not be_nil
+    expect(@q.peek(:ready)).to_not be_nil
     job = @q.reserve
-    job.beanstalk_job.stats["releases"].should eql(0)
-    job.beanstalk_job.stats["delay"].should eql(0)
-    lambda{job.perform}.should raise_exception(Quebert::Job::Timeout)
+    expect(job.beanstalk_job.stats["releases"]).to eql(0)
+    expect(job.beanstalk_job.stats["delay"]).to eql(0)
+    expect {
+      job.perform
+    }.to raise_exception(Quebert::Job::Timeout)
 
-    @q.peek(:ready).should be_nil
+    expect(@q.peek(:ready)).to be_nil
     beanstalk_job = @q.peek(:delayed)
-    beanstalk_job.should_not be_nil
-    beanstalk_job.stats["releases"].should eql(1)
-    beanstalk_job.stats["delay"].should eql(Quebert::Controller::Beanstalk::TIMEOUT_RETRY_GROWTH_RATE**beanstalk_job.stats["releases"])
+    expect(beanstalk_job).to_not be_nil
+    expect(beanstalk_job.stats["releases"]).to eql(1)
+    expect(beanstalk_job.stats["delay"]).to eql(Quebert::Controller::Beanstalk::TIMEOUT_RETRY_GROWTH_RATE**beanstalk_job.stats["releases"])
 
     sleep(3)
 
     # lets set the max retry delay so it should bury instead of delay
     redefine_constant Quebert::Controller::Beanstalk, :MAX_TIMEOUT_RETRY_DELAY, 1
-    lambda{@q.reserve.perform}.should raise_exception(Quebert::Job::Timeout)
+    expect {
+      @q.reserve.perform
+    }.to raise_exception(Quebert::Job::Timeout)
 
-    @q.peek(:ready).should be_nil
-    @q.peek(:delayed).should be_nil
-    @q.peek(:buried).should_not be_nil
+    expect(@q.peek(:ready)).to be_nil
+    expect(@q.peek(:delayed)).to be_nil
+    expect(@q.peek(:buried)).to_not be_nil
   end
 end

data/spec/job_spec.rb

@@ -7,21 +7,23 @@ describe Quebert::Job do
   end
 
   it "shoud initialize with block" do
-    Adder.new(1,2,3){|a| a.priority = 8080 }.priority.should == 8080
+    expect(
+      Adder.new(1,2,3){|a| a.priority = 8080 }.priority
+    ).to eql(8080)
   end
 
   it "should perform!" do
-    Adder.new(1,2,3).perform!.should eql(6)
+    expect(Adder.new(1,2,3).perform!).to eql(6)
   end
 
   it "should perform 0 arg jobs" do
-    Adder.new.perform!.should eql(0)
+    expect(Adder.new.perform!).to eql(0)
   end
 
   it "should raise not implemented on base job" do
-    lambda {
+    expect {
       Job.new.perform
-    }.should raise_exception(NotImplementedError)
+    }.to raise_exception(NotImplementedError)
   end
 
   it "should convert job to and from JSON" do
@@ -30,69 +32,69 @@ describe Quebert::Job do
     job.queue = "foo"
     serialized = job.to_json
     unserialized = Adder.from_json(serialized)
-    unserialized.should be_a(Adder)
-    unserialized.args.should eql(args)
-    unserialized.queue.should eql("foo")
+    expect(unserialized).to be_a(Adder)
+    expect(unserialized.args).to eql(args)
+    expect(unserialized.queue).to eql("foo")
   end
 
   it "should have default MEDIUM priority" do
-    Job.new.priority.should == Quebert::Job::Priority::MEDIUM
+    expect(Job.new.priority).to eql(Quebert::Job::Priority::MEDIUM)
   end
 
   describe "Quebert::Job::Priority" do
     it "should have LOW priority of 4294967296" do
-      Quebert::Job::Priority::LOW.should == 4294967296
+      expect(Quebert::Job::Priority::LOW).to eql(4294967296)
     end
     it "should have MEDIUM priority of 2147483648" do
-      Quebert::Job::Priority::MEDIUM.should == 2147483648
+      expect(Quebert::Job::Priority::MEDIUM).to eql(2147483648)
     end
     it "should have HIGH priority of 0" do
-      Quebert::Job::Priority::HIGH.should == 0
+      expect(Quebert::Job::Priority::HIGH).to eql(0)
     end
   end
 
   context "actions" do
     it "should raise release" do
-      lambda{
+      expect {
         ReleaseJob.new.perform
-      }.should raise_exception(Job::Release)
+      }.to raise_exception(Job::Release)
     end
 
     it "should raise delete" do
-      lambda{
+      expect {
         DeleteJob.new.perform
-      }.should raise_exception(Job::Delete)
+      }.to raise_exception(Job::Delete)
     end
 
     it "should raise bury" do
-      lambda{
+      expect {
         BuryJob.new.perform
-      }.should raise_exception(Job::Bury)
+      }.to raise_exception(Job::Bury)
     end
   end
 
   context "job queue" do
     it "should enqueue" do
-      lambda{
+      expect {
         Adder.new(1,2,3).enqueue
-      }.should change(@q, :size).by(1)
+      }.to change(@q, :size).by(1)
     end
 
     context "#enqueue options" do
       let(:job){ Adder.new(1,2,3) }
 
       it "should enqueue with pri" do
-        job.should_receive(:pri=).with(100)
+        expect(job).to receive(:pri=).with(100)
         job.enqueue(:pri => 100)
       end
 
       it "should enqueue with ttr" do
-        job.should_receive(:ttr=).with(90)
+        expect(job).to receive(:ttr=).with(90)
         job.enqueue(:ttr => 90)
       end
 
       it "should enqueue with delay" do
-        job.should_receive(:delay=).with(80)
+        expect(job).to receive(:delay=).with(80)
         job.enqueue(:delay => 80)
       end
     end
@@ -114,17 +116,17 @@ describe Quebert::Job do
           user = User.new(:first_name => "Steel")
           user.async(:priority => 1, :delay => 2, :ttr => 300).email!("somebody", nil, nil)
           job = @q.reserve
-          job.beanstalk_job.pri.should eql(1)
-          job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
+          expect(job.beanstalk_job.pri).to eql(1)
+          expect(job.beanstalk_job.delay).to eql(2)
+          expect(job.beanstalk_job.ttr).to eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
 
         it "should enqueue and honor beanstalk options" do
           User.async(:priority => 1, :delay => 2, :ttr => 300).emailizer("somebody", nil, nil)
           job = @q.reserve
-          job.beanstalk_job.pri.should eql(1)
-          job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
+          expect(job.beanstalk_job.pri).to eql(1)
+          expect(job.beanstalk_job.delay).to eql(2)
+          expect(job.beanstalk_job.ttr).to eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
       end
 
@@ -133,17 +135,76 @@ describe Quebert::Job do
           user = User.new(:first_name => "Steel")
           user.async_send(:email!, "somebody", nil, nil, :beanstalk => {:priority => 1, :delay => 2, :ttr => 300})
           job = @q.reserve
-          job.beanstalk_job.pri.should eql(1)
-          job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
+          expect(job.beanstalk_job.pri).to eql(1)
+          expect(job.beanstalk_job.delay).to eql(2)
+          expect(job.beanstalk_job.ttr).to eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
 
         it "should enqueue and honor beanstalk options" do
           User.async_send(:emailizer, "somebody", nil, nil, :beanstalk => {:priority => 1, :delay => 2, :ttr => 300})
           job = @q.reserve
-          job.beanstalk_job.pri.should eql(1)
-          job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
+          expect(job.beanstalk_job.pri).to eql(1)
+          expect(job.beanstalk_job.delay).to eql(2)
+          expect(job.beanstalk_job.ttr).to eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
+        end
+      end
+
+      describe "Beanstalk event hooks" do
+        it "calls the bury event hook" do
+          class BuryJob
+            attr_accessor :before_bury_ran, :after_bury_ran
+            def around_bury
+              self.before_bury_ran = true
+              yield
+              self.after_bury_ran = true
+            end
+          end
+          BuryJob.backend = @q
+          job = BuryJob.new.tap(&:enqueue)
+          controller = @q.reserve
+          expect(controller.job.before_bury_ran).to be_falsey
+          expect(controller.job.after_bury_ran).to be_falsey
+          controller.perform
+          expect(controller.job.before_bury_ran).to be_truthy
+          expect(controller.job.after_bury_ran).to be_truthy
+        end
+
+        it "calls the delete event hook" do
+          class DeleteJob
+            attr_accessor :before_delete_ran, :after_delete_ran
+            def around_delete
+              self.before_delete_ran = true
+              yield
+              self.after_delete_ran = true
+            end
+          end
+          DeleteJob.backend = @q
+          job = DeleteJob.new.tap(&:enqueue)
+          controller = @q.reserve
+          expect(controller.job.before_delete_ran).to be_falsey
+          expect(controller.job.after_delete_ran).to be_falsey
+          controller.perform
+          expect(controller.job.before_delete_ran).to be_truthy
+          expect(controller.job.after_delete_ran).to be_truthy
+        end
+
+        it "calls the release event hook" do
+          class ReleaseJob
+            attr_accessor :before_release_ran, :after_release_ran
+            def around_release
+              self.before_release_ran = true
+              yield
+              self.after_release_ran = true
+            end
+          end
+          ReleaseJob.backend = @q
+          job = ReleaseJob.new.tap(&:enqueue)
+          controller = @q.reserve
+          expect(controller.job.before_release_ran).to be_falsey
+          expect(controller.job.after_release_ran).to be_falsey
+          controller.perform
+          expect(controller.job.before_release_ran).to be_truthy
+          expect(controller.job.after_release_ran).to be_truthy
         end
       end
     end
@@ -151,9 +212,9 @@ describe Quebert::Job do
 
   context "Timeout" do
     it "should respect TTR option" do
-      lambda {
+      expect {
         TimeoutJob.new.perform!
-      }.should raise_exception(Quebert::Job::Timeout)
+      }.to raise_exception(Quebert::Job::Timeout)
     end
   end
 
@@ -181,10 +242,10 @@ describe Quebert::Job do
 
       jobs.each(&:perform!)
 
-      before_jobs.should eql jobs
-      after_jobs.should  eql jobs
+      expect(before_jobs).to eql jobs
+      expect(after_jobs).to  eql jobs
       # around_job hooks are called twice per job (before & after its performed)
-      around_jobs.should eql jobs.zip(jobs).flatten
+      expect(around_jobs).to eql jobs.zip(jobs).flatten
     end
   end
 end

data/spec/quebert_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe Quebert do
-  
   it "should have configuration keys" do
-    Quebert.configuration.should respond_to(:backend)
+    expect(Quebert.configuration).to respond_to(:backend)
   end
-end
+end

data/spec/serializer_spec.rb

@@ -6,31 +6,31 @@ describe Serializer::ActiveRecord do
 
     it "should serialize" do
       h = Serializer::ActiveRecord.serialize(user)
-      h['model'].should eql('User')
-      h['attributes']['first_name'].should eql('Tom')
-      h['attributes']['id'].should eql(user.id)
+      expect(h['model']).to eql('User')
+      expect(h['attributes']['first_name']).to eql('Tom')
+      expect(h['attributes']['id']).to eql(user.id)
     end
-    
+
     it "should deserialize" do
       u = Serializer::ActiveRecord.deserialize(Serializer::ActiveRecord.serialize(user))
-      u.first_name.should eql('Tom')
-      u.id.should eql(user.id)
+      expect(u.first_name).to eql('Tom')
+      expect(u.id).to eql(user.id)
     end
   end
-  
+
   context "unpersisted" do
     let(:user) { User.new(:first_name => 'brad') }
 
     it "should serialize" do
       h = Serializer::ActiveRecord.serialize(user)
-      h['model'].should eql('User')
-      h['attributes']['first_name'].should eql('brad')
-      h['attributes']['id'].should be_nil
+      expect(h['model']).to eql('User')
+      expect(h['attributes']['first_name']).to eql('brad')
+      expect(h['attributes']['id']).to be_nil
     end
-    
+
     it "should deserialize" do
       u = Serializer::ActiveRecord.deserialize(Serializer::ActiveRecord.serialize(user))
-      u.first_name.should eql('brad')
+      expect(u.first_name).to eql('brad')
     end
   end
 end
@@ -50,44 +50,44 @@ describe Serializer::Job do
 
   describe "#serialize" do
     it "shold have job" do
-      serialized['job'].should eql('Quebert::Job')
+      expect(serialized['job']).to eql('Quebert::Job')
     end
 
     it "should have args" do
-      serialized['args'][0]['payload'].should eql(100)
-      serialized['args'][1]['payload'].should eql(Serializer::ActiveRecord.serialize(args[1]))
-      serialized['args'][1]['serializer'].should eql('Quebert::Serializer::ActiveRecord')
+      expect(serialized['args'][0]['payload']).to eql(100)
+      expect(serialized['args'][1]['payload']).to eql(Serializer::ActiveRecord.serialize(args[1]))
+      expect(serialized['args'][1]['serializer']).to eql('Quebert::Serializer::ActiveRecord')
     end
 
     it "should have priority" do
-      serialized['priority'].should eql(1)
+      expect(serialized['priority']).to eql(1)
     end
 
     it "should have delay" do
-      serialized['delay'].should eql(2)
+      expect(serialized['delay']).to eql(2)
     end
 
     it "should have ttr" do
-      serialized['ttr'].should eql(300)
+      expect(serialized['ttr']).to eql(300)
     end
   end
 
   describe "#deserialize" do
     it "should have args" do
-      deserialized.args[0].should eql(100)
-      deserialized.args[1].first_name.should eql('Brad')
+      expect(deserialized.args[0]).to eql(100)
+      expect(deserialized.args[1].first_name).to eql('Brad')
     end
 
     it "should have delay" do
-      deserialized.delay.should eql(2)
+      expect(deserialized.delay).to eql(2)
     end
 
     it "should have priority" do
-      deserialized.priority.should eql(1)
+      expect(deserialized.priority).to eql(1)
     end
 
     it "should have ttr" do
-      deserialized.ttr.should eql(300)
+      expect(deserialized.ttr).to eql(300)
     end
   end
 end

data/spec/support/jobs.rb

@@ -36,6 +36,6 @@ end
 
 class Exceptional < Quebert::Job
   def perform
-    fail
+    fail "Exceptional"
   end
 end

data/spec/support_spec.rb

@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Support::ClassRegistry do
   Super = Class.new
   Sub   = Class.new(Super)
-  
+
   before(:all) do
     @registry = Support::ClassRegistry.new
   end
-  
+
   it "should store class symbols" do
     @registry[:'Super'] = Super
-    @registry[:'Super'].should eql(Super)
+    expect(@registry[:'Super']).to eql(Super)
   end
-  
+
   it "should retrieve class keys" do
-    @registry[Super].should eql(Super)
+    expect(@registry[Super]).to eql(Super)
   end
-  
+
   it "should retrieve subclass keys" do
-    @registry[Sub].should eql(Super)
+    expect(@registry[Sub]).to eql(Super)
   end
-end
+end

data/spec/worker_spec.rb

@@ -8,26 +8,26 @@ describe Worker do
     end
   end
 
-  it "should start" do
+  it "starts" do
     @w.start
   end
 
   context "pluggable exception handler" do
-    it "should raise exception if nothing is provided" do
+    it "raises exception if nothing is provided" do
       @q.put Exceptional.new
-      lambda{ @w.start }.should raise_exception
+      expect { @w.start }.to raise_exception(RuntimeError, "Exceptional")
     end
 
-    it "should default to Quebert.config.worker.exception_handler handler" do
+    it "defaults to Quebert.config.worker.exception_handler handler" do
       @q.put Exceptional.new
-      Quebert.config.worker.exception_handler = Proc.new{|e, opts| e.should be_a(StandardError) }
-      lambda{ @w.start }.should_not raise_exception
+      Quebert.config.worker.exception_handler = Proc.new{|e, opts| expect(e).to be_a(StandardError) }
+      expect { @w.start }.to_not raise_exception
     end
 
-    it "should intercept exceptions" do
+    it "intercepts exceptions" do
       @q.put Exceptional.new
-      @w.exception_handler = Proc.new{|e, opts| e.should be_a(StandardError) }
-      lambda{ @w.start }.should_not raise_exception
+      @w.exception_handler = Proc.new{|e, opts| expect(e).to be_a(StandardError) }
+      expect { @w.start }.to_not raise_exception
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quebert
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.2.0
 platform: ruby
 authors:
 - Brad Gessler
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-29 00:00:00.000000000 Z
+date: 2017-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -67,6 +67,7 @@ files:
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE.md
@@ -131,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: quebert
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: A worker queue framework built around beanstalkd