canvas-jobs 0.9.0

data/lib/delayed/yaml_extensions.rb

@@ -0,0 +1,63 @@
+# New definitions for YAML to aid in serialization and deserialization of delayed jobs.
+
+require 'yaml'
+require 'syck'
+# this code needs to be updated to work with the new Psych YAML engine in ruby 1.9.x
+# for now we force Syck
+YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE) && YAML::ENGINE.yamler != 'syck'
+
+# First, tell YAML how to load a Module. This depends on Rails .constantize and autoloading.
+YAML.add_ruby_type("object:Module") do |type, val|
+  val.constantize
+end
+
+class Module
+  def to_yaml(opts = {})
+    YAML.quick_emit(self.object_id, opts) do |out|
+      out.scalar(taguri, name)
+    end
+  end
+end
+
+# Now we have to do the same for Class.
+YAML.add_ruby_type("object:Class") do |type, val|
+  val.constantize
+end
+
+class Class
+  def to_yaml(opts = {})
+    YAML.quick_emit(self.object_id, opts) do |out|
+      out.scalar(taguri, name)
+    end
+  end
+end
+
+# Now, tell YAML how to intelligently load ActiveRecord objects, using the
+# database rather than just serializing their attributes to the YAML. This
+# ensures the object is up to date when we use it in the job.
+class ActiveRecord::Base
+  yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
+
+  def to_yaml(opts = {})
+    if id.nil?
+      raise("Can't serialize unsaved ActiveRecord object for delayed job: #{self.inspect}")
+    end
+    YAML.quick_emit(self.object_id, opts) do |out|
+      out.scalar(taguri, id.to_s)
+    end
+  end
+
+  def self.yaml_new(klass, tag, val)
+    klass.find(val)
+  rescue ActiveRecord::RecordNotFound
+    raise Delayed::Backend::RecordNotFound, "Couldn't find #{klass} with id #{val.inspect}"
+  end
+end
+
+# Load Module/Class from yaml tag.
+class Module
+  def yaml_tag_read_class(name)
+    name.constantize
+    name
+  end
+end

data/lib/delayed_job.rb

@@ -0,0 +1,40 @@
+module Delayed
+  MIN_PRIORITY = 0
+  HIGH_PRIORITY = 0
+  NORMAL_PRIORITY = 10
+  LOW_PRIORITY = 20
+  LOWER_PRIORITY = 50
+  MAX_PRIORITY = 1_000_000
+
+  def self.select_backend(backend)
+    remove_const(:Job) if defined?(::Delayed::Job)
+    const_set(:Job, backend)
+  end
+end
+
+require 'rails'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_record'
+require 'after_transaction_commit'
+
+require 'delayed/settings'
+require 'delayed/yaml_extensions'
+
+require 'delayed/backend/base'
+require 'delayed/backend/active_record'
+require 'delayed/backend/redis/job'
+require 'delayed/batch'
+require 'delayed/job_tracking'
+require 'delayed/lifecycle'
+require 'delayed/message_sending'
+require 'delayed/performable_method'
+require 'delayed/periodic'
+require 'delayed/pool'
+require 'delayed/worker'
+
+require 'delayed/engine'
+
+Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
+
+Object.send(:include, Delayed::MessageSending)
+Module.send(:include, Delayed::MessageSending::ClassMethods)

data/spec/active_record_job_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe 'Delayed::Backed::ActiveRecord::Job' do
+  before :all do
+    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
+  end
+
+  after :all do
+    Delayed.send(:remove_const, :Job)
+  end
+
+  before do
+    Delayed::Job.delete_all
+    Delayed::Job::Failed.delete_all
+  end
+
+  include_examples 'a delayed_jobs implementation'
+
+  it "should recover as well as possible from a failure failing a job" do
+    allow(Delayed::Job::Failed).to receive(:create).and_raise(RuntimeError)
+    job = "test".send_later_enqueue_args :reverse, no_delay: true
+    job_id = job.id
+    proc { job.fail! }.should raise_error
+    proc { Delayed::Job.find(job_id) }.should raise_error(ActiveRecord::RecordNotFound)
+    Delayed::Job.count.should == 0
+  end
+
+  context "when another worker has worked on a task since the job was found to be available, it" do
+    before :each do
+      @job = Delayed::Job.create :payload_object => SimpleJob.new
+      @job_copy_for_worker_2 = Delayed::Job.find(@job.id)
+    end
+
+    it "should not allow a second worker to get exclusive access if already successfully processed by worker1" do
+      @job.destroy
+      @job_copy_for_worker_2.lock_exclusively!('worker2').should == false
+    end
+
+    it "should not allow a second worker to get exclusive access if failed to be processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
+      @job.update_attributes(:attempts => 1, :run_at => 1.day.from_now)
+      @job_copy_for_worker_2.lock_exclusively!('worker2').should == false
+    end
+
+    it "should select the next job at random if enabled" do
+      begin
+        Delayed::Settings.select_random_from_batch = true
+        15.times { "test".send_later :length }
+        founds = []
+        15.times do
+          job = Delayed::Job.get_and_lock_next_available('tester')
+          founds << job
+          job.unlock
+          job.save!
+        end
+        founds.uniq.size.should > 1
+      ensure
+        Delayed::Settings.select_random_from_batch = false
+      end
+    end
+  end
+end

data/spec/gemfiles/32.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path=>"../../"
+
+gem "rails", "~> 3.2.19"
+

data/spec/gemfiles/40.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path=>"../../"
+
+gem "rails", "~> 4.0.10"
+

data/spec/gemfiles/41.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path=>"../../"
+
+gem "rails", "~> 4.1.6"
+

data/spec/gemfiles/42.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path=>"../../"
+
+gem "rails", "~> 4.2.0.beta2"
+

data/spec/migrate/20140924140513_add_story_table.rb

@@ -0,0 +1,7 @@
+class AddStoryTable < ActiveRecord::Migration
+  def change
+    create_table :stories do |table|
+      table.string :text
+    end
+  end
+end

data/spec/redis_job_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe 'Delayed::Backend::Redis::Job' do
+  before :all do
+    Delayed.select_backend(Delayed::Backend::Redis::Job)
+  end
+
+  after :all do
+    Delayed.send(:remove_const, :Job)
+  end
+
+  before do
+    Delayed::Job.redis.flushdb
+  end
+
+  include_examples 'a delayed_jobs implementation'
+
+  describe "tickle_strand" do
+    it "should continue trying to tickle until the strand is empty" do
+      jobs = []
+      3.times { jobs << "test".send_later_enqueue_args(:to_s, :strand => "s1", :no_delay => true) }
+      job = "test".send_later_enqueue_args(:to_s, :strand => "s1", :no_delay => true)
+      # manually delete the first jobs, bypassing the strand book-keeping
+      jobs.each { |j| Delayed::Job.redis.del(Delayed::Job::Keys::JOB[j.id]) }
+      Delayed::Job.redis.llen(Delayed::Job::Keys::STRAND['s1']).should == 4
+      job.destroy
+      Delayed::Job.redis.llen(Delayed::Job::Keys::STRAND['s1']).should == 0
+    end
+
+    it "should tickle until it finds an existing job" do
+      jobs = []
+      3.times { jobs << "test".send_later_enqueue_args(:to_s, :strand => "s1", :no_delay => true) }
+      job = "test".send_later_enqueue_args(:to_s, :strand => "s1", :no_delay => true)
+      # manually delete the first jobs, bypassing the strand book-keeping
+      jobs[0...-1].each { |j| Delayed::Job.redis.del(Delayed::Job::Keys::JOB[j.id]) }
+      Delayed::Job.redis.llen(Delayed::Job::Keys::STRAND['s1']).should == 4
+      jobs[-1].destroy
+      Delayed::Job.redis.lrange(Delayed::Job::Keys::STRAND['s1'], 0, -1).should == [job.id]
+      found = [Delayed::Job.get_and_lock_next_available('test worker'),
+               Delayed::Job.get_and_lock_next_available('test worker')]
+      found.should =~ [job, nil]
+    end
+  end
+
+  describe "missing jobs in queues" do
+    before do
+      @job = "test".send_later_enqueue_args(:to_s, :no_delay => true)
+      @job2 = "test".send_later_enqueue_args(:to_s, :no_delay => true)
+      # manually delete the job from redis
+      Delayed::Job.redis.del(Delayed::Job::Keys::JOB[@job.id])
+    end
+
+    it "should discard when trying to lock" do
+      found = [Delayed::Job.get_and_lock_next_available("test worker"),
+               Delayed::Job.get_and_lock_next_available("test worker")]
+      found.should =~ [@job2, nil]
+    end
+
+    it "should filter for find_available" do
+      found = [Delayed::Job.find_available(1),
+               Delayed::Job.find_available(1)]
+      found.should be_include([@job2])
+    end
+  end
+
+  describe "send_later" do
+    it "should schedule job on transaction commit" do
+      before_count = Delayed::Job.jobs_count(:current)
+      ActiveRecord::Base.transaction do
+        job = "string".send_later :reverse
+        job.should be_nil
+        Delayed::Job.jobs_count(:current).should == before_count
+      end
+      Delayed::Job.jobs_count(:current) == before_count + 1
+    end
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,26 @@
+class SimpleJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; @@runs += 1; end
+end
+
+class ErrorJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; raise 'did not work'; end
+
+  cattr_accessor :failure_runs; self.failure_runs = 0
+  def on_failure(error); @@failure_runs += 1; end
+
+  cattr_accessor :permanent_failure_runs; self.permanent_failure_runs = 0
+  def on_permanent_failure(error); @@permanent_failure_runs += 1; end
+end
+
+class LongRunningJob
+  def perform; sleep 250; end
+end
+
+module M
+  class ModuleJob
+    cattr_accessor :runs; self.runs = 0
+    def perform; @@runs += 1; end
+  end
+end

data/spec/shared/delayed_batch.rb

@@ -0,0 +1,85 @@
+shared_examples_for 'Delayed::Batch' do
+  context "batching" do
+    it "should batch up all deferrable delayed methods" do
+      later = 1.hour.from_now
+      Delayed::Batch.serial_batch {
+        "string".send_later_enqueue_args(:size, no_delay: true).should be true
+        "string".send_later_enqueue_args(:reverse, run_at: later, no_delay: true).should be_truthy # won't be batched, it'll get its own job
+        "string".send_later_enqueue_args(:gsub, { no_delay: true }, /./, "!").should be_truthy
+      }
+      batch_jobs = Delayed::Job.find_available(5)
+      regular_jobs = Delayed::Job.list_jobs(:future, 5)
+      regular_jobs.size.should == 1
+      regular_jobs.first.batch?.should == false
+      batch_jobs.size.should == 1
+      batch_job = batch_jobs.first
+      batch_job.batch?.should == true
+      batch_job.payload_object.mode.should  == :serial
+      batch_job.payload_object.jobs.map { |j| [j.payload_object.object, j.payload_object.method, j.payload_object.args] }.should  == [
+        ["string", :size, []],
+        ["string", :gsub, [/./, "!"]]
+      ]
+    end
+
+    it "should not let you invoke it directly" do
+      later = 1.hour.from_now
+      Delayed::Batch.serial_batch {
+        "string".send_later_enqueue_args(:size, no_delay: true).should be true
+        "string".send_later_enqueue_args(:gsub, { no_delay: true }, /./, "!").should be true
+      }
+      Delayed::Job.jobs_count(:current).should == 1
+      job = Delayed::Job.find_available(1).first
+      expect{ job.invoke_job }.to raise_error
+    end
+
+    it "should create valid jobs" do
+      Delayed::Batch.serial_batch {
+        "string".send_later_enqueue_args(:size, no_delay: true).should be true
+        "string".send_later_enqueue_args(:gsub, { no_delay: true }, /./, "!").should be true
+      }
+      Delayed::Job.jobs_count(:current).should == 1
+
+      batch_job = Delayed::Job.find_available(1).first
+      batch_job.batch?.should == true
+      jobs = batch_job.payload_object.jobs
+      jobs.size.should == 2
+      jobs[0].should be_new_record
+      jobs[0].payload_object.class.should   == Delayed::PerformableMethod
+      jobs[0].payload_object.method.should  == :size
+      jobs[0].payload_object.args.should    == []
+      jobs[0].payload_object.perform.should == 6
+      jobs[1].should be_new_record
+      jobs[1].payload_object.class.should   == Delayed::PerformableMethod
+      jobs[1].payload_object.method.should  == :gsub
+      jobs[1].payload_object.args.should    == [/./, "!"]
+      jobs[1].payload_object.perform.should == "!!!!!!"
+    end
+
+    it "should create a different batch for each priority" do
+      later = 1.hour.from_now
+      Delayed::Batch.serial_batch {
+        "string".send_later_enqueue_args(:size, :priority => Delayed::LOW_PRIORITY, :no_delay => true).should be true
+        "string".send_later_enqueue_args(:gsub, { :no_delay => true }, /./, "!").should be true
+      }
+      Delayed::Job.jobs_count(:current).should == 2
+    end
+
+    it "should use the given priority for all, if specified" do
+      Delayed::Batch.serial_batch(:priority => 11) {
+        "string".send_later_enqueue_args(:size, :priority => 20, :no_delay => true).should be true
+        "string".send_later_enqueue_args(:gsub, { :priority => 15, :no_delay => true }, /./, "!").should be true
+      }
+      Delayed::Job.jobs_count(:current).should == 1
+      Delayed::Job.find_available(1).first.priority.should == 11
+    end
+
+    it "should just create the job, if there's only one in the batch" do
+      Delayed::Batch.serial_batch(:priority => 11) {
+        "string".send_later_enqueue_args(:size, no_delay: true).should be true
+      }
+      Delayed::Job.jobs_count(:current).should == 1
+      Delayed::Job.find_available(1).first.tag.should == "String#size"
+      Delayed::Job.find_available(1).first.priority.should == 11
+    end
+  end
+end

data/spec/shared/delayed_method.rb

@@ -0,0 +1,419 @@
+shared_examples_for 'random ruby objects' do
+  def set_queue(name)
+    old_name = Delayed::Settings.queue
+    Delayed::Settings.queue = name
+  ensure
+    Delayed::Settings.queue = old_name
+  end
+
+  it "should respond_to :send_later method" do
+    Object.new.respond_to?(:send_later)
+  end
+
+  it "should raise a ArgumentError if send_later is called but the target method doesn't exist" do
+    lambda { Object.new.send_later(:method_that_deos_not_exist) }.should raise_error(NoMethodError)
+  end
+
+  it "should add a new entry to the job table when send_later is called on it" do
+    lambda { Object.new.send_later(:to_s) }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+  end
+
+  it "should add a new entry to the job table when send_later_with_queue is called on it" do
+    lambda { Object.new.send_later_with_queue(:to_s, "testqueue") }.should change { Delayed::Job.jobs_count(:current, "testqueue") }.by(1)
+  end
+
+  it "should add a new entry to the job table when send_later is called on the class" do
+    lambda { Object.send_later(:to_s) }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+  end
+
+  it "should add a new entry to the job table when send_later_with_queue is called on the class" do
+    lambda { Object.send_later_with_queue(:to_s, "testqueue") }.should change { Delayed::Job.jobs_count(:current, "testqueue") }.by(1)
+  end
+
+  context "class methods" do
+    context "add_send_later_methods" do
+      it "should work with default_async" do
+        class TestObject
+          attr_reader :ran
+          def test_method; @ran = true; end
+          add_send_later_methods :test_method, {}, true
+        end
+        obj = TestObject.new
+        lambda { obj.test_method }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        lambda { obj.test_method_with_send_later }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        obj.ran.should be_falsey
+        lambda { obj.test_method_without_send_later }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should be true
+      end
+
+      it "should work without default_async" do
+        class TestObject
+          attr_accessor :ran
+          def test_method; @ran = true; end
+          add_send_later_methods :test_method, {}, false
+        end
+        obj = TestObject.new
+        lambda { obj.test_method_with_send_later }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        obj.ran.should be_falsey
+        lambda { obj.test_method }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should be true
+        obj.ran = false
+        obj.ran.should be false
+        lambda { obj.test_method_without_send_later }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should be true
+      end
+
+      it "should send along enqueue args and args default async" do
+        class TestObject
+          attr_reader :ran
+          def test_method(*args); @ran = args; end
+          add_send_later_methods(:test_method, {:enqueue_arg_1 => :thing}, true)
+        end
+        obj = TestObject.new
+        method = double()
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method_without_send_later, [1,2,3]).and_return(method)
+        expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
+        obj.test_method(1,2,3)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method_without_send_later, [4]).and_return(method)
+        expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
+        obj.test_method(4)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method_without_send_later, [6]).and_return(method)
+        expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
+        obj.test_method_with_send_later(6)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method_without_send_later, [5,6]).and_return(method)
+        expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
+        obj.test_method_with_send_later(5,6)
+        obj.ran.should be_nil
+        obj.test_method_without_send_later(7)
+        obj.ran.should == [7]
+        obj.ran = nil
+        obj.ran.should == nil
+        obj.test_method_without_send_later(8,9)
+        obj.ran.should == [8,9]
+      end
+
+      it "should send along enqueue args and args without default async" do
+        class TestObject
+          attr_reader :ran
+          def test_method(*args); @ran = args; end
+          add_send_later_methods(:test_method, {:enqueue_arg_2 => :thing2}, false)
+        end
+        obj = TestObject.new
+        method = double()
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method_without_send_later, [6]).and_return(method)
+        expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_2 => :thing2)
+        obj.test_method_with_send_later(6)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method_without_send_later, [5,6]).and_return(method)
+        expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_2 => :thing2)
+        obj.test_method_with_send_later(5,6)
+        obj.ran.should be_nil
+        obj.test_method(1,2,3)
+        obj.ran.should == [1,2,3]
+        obj.ran = nil
+        obj.ran.should == nil
+        obj.test_method(4)
+        obj.ran.should == [4]
+        obj.ran = nil
+        obj.ran.should == nil
+        obj.test_method_without_send_later(7)
+        obj.ran.should == [7]
+        obj.ran = nil
+        obj.ran.should == nil
+        obj.test_method_without_send_later(8,9)
+        obj.ran.should == [8,9]
+      end
+
+      it "should handle punctuation correctly with default_async" do
+        class TestObject
+          attr_reader :ran
+          def test_method?; @ran = true; end
+          add_send_later_methods :test_method?, {}, true
+        end
+        obj = TestObject.new
+        lambda { obj.test_method? }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        lambda { obj.test_method_with_send_later? }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        obj.ran.should be_falsey
+        lambda { obj.test_method_without_send_later? }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should be true
+      end
+
+      it "should handle punctuation correctly without default_async" do
+        class TestObject
+          attr_accessor :ran
+          def test_method?; @ran = true; end
+          add_send_later_methods :test_method?, {}, false
+        end
+        obj = TestObject.new
+        lambda { obj.test_method_with_send_later? }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        obj.ran.should be_falsey
+        lambda { obj.test_method? }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should be true
+        obj.ran = false
+        obj.ran.should be false
+        lambda { obj.test_method_without_send_later? }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should be true
+      end
+
+      it "should handle assignment punctuation correctly with default_async" do
+        class TestObject
+          attr_reader :ran
+          def test_method=(val); @ran = val; end
+          add_send_later_methods :test_method=, {}, true
+        end
+        obj = TestObject.new
+        lambda { obj.test_method = 3 }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        lambda { obj.test_method_with_send_later = 4 }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        obj.ran.should be_nil
+        lambda { obj.test_method_without_send_later = 5 }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should == 5
+      end
+
+      it "should handle assignment punctuation correctly without default_async" do
+        class TestObject
+          attr_accessor :ran
+          def test_method=(val); @ran = val; end
+          add_send_later_methods :test_method=, {}, false
+        end
+        obj = TestObject.new
+        lambda { obj.test_method_with_send_later = 1 }.should change { Delayed::Job.jobs_count(:current) }.by(1)
+        obj.ran.should be_nil
+        lambda { obj.test_method = 2 }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should == 2
+        lambda { obj.test_method_without_send_later = 3 }.should_not change { Delayed::Job.jobs_count(:current) }
+        obj.ran.should == 3
+      end
+
+      it "should correctly sort out method accessibility with default async" do
+        class TestObject1
+          def test_method; end
+          add_send_later_methods :test_method, {}, true
+        end
+        class TestObject2
+          protected
+          def test_method; end
+          add_send_later_methods :test_method, {}, true
+        end
+        class TestObject3
+          private
+          def test_method; end
+          add_send_later_methods :test_method, {}, true
+        end
+        TestObject1.public_method_defined?(:test_method).should be true
+        TestObject2.public_method_defined?(:test_method).should be false
+        TestObject3.public_method_defined?(:test_method).should be false
+        TestObject2.protected_method_defined?(:test_method).should be true
+        TestObject3.protected_method_defined?(:test_method).should be false
+        TestObject3.private_method_defined?(:test_method).should be true
+      end
+    end
+
+    context "handle_asynchonously_if_production" do
+      it "should work in production" do
+        expect(Rails.env).to receive(:production?).and_return(true)
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {}, true)
+        class TestObject
+          def test_method; end
+          handle_asynchronously_if_production :test_method
+        end
+      end
+
+      it "should work in other environments" do
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {}, false)
+        class TestObject
+          def test_method; end
+          handle_asynchronously_if_production :test_method
+        end
+      end
+
+      it "should pass along enqueue args in production" do
+        expect(Rails.env).to receive(:production?).and_return(true)
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {:enqueue_arg_1 => true}, true)
+        class TestObject
+          def test_method; end
+          handle_asynchronously_if_production :test_method, :enqueue_arg_1 => true
+        end
+      end
+
+      it "should pass along enqueue args in other environments" do
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {:enqueue_arg_2 => "thing", :enqueue_arg_3 => 4}, false)
+        class TestObject
+          def test_method; end
+          handle_asynchronously_if_production :test_method, :enqueue_arg_2 => "thing", :enqueue_arg_3 => 4
+        end
+      end
+    end
+
+    context "handle_asynchronously" do
+      it "should work without enqueue_args" do
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {}, true)
+        class TestObject
+          def test_method; end
+          handle_asynchronously :test_method
+        end
+      end
+
+      it "should work with enqueue_args" do
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {:enqueue_arg_1 => :thing}, true)
+        class TestObject
+          def test_method; end
+          handle_asynchronously :test_method, :enqueue_arg_1 => :thing
+        end
+      end
+    end
+
+    context "handle_asynchronously_with_queue" do
+      it "should pass along the queue" do
+        class TestObject; end
+        expect(TestObject).to receive(:add_send_later_methods).with(:test_method, {:queue => "myqueue"}, true)
+        class TestObject
+          def test_method; end
+          handle_asynchronously_with_queue :test_method, "myqueue"
+        end
+      end
+    end
+  end
+
+  it "should call send later on methods which are wrapped with handle_asynchronously" do
+    story = Story.create :text => 'Once upon...'
+
+    expect { story.whatever(1, 5) }.to change { Delayed::Job.jobs_count(:current) }.by(1)
+
+    job = Delayed::Job.list_jobs(:current, 1).first
+    job.payload_object.class.should   == Delayed::PerformableMethod
+    job.payload_object.method.should  == :whatever_without_send_later
+    job.payload_object.args.should    == [1, 5]
+    job.payload_object.perform.should == 'Once upon...'
+  end
+
+  it "should call send later on methods which are wrapped with handle_asynchronously_with_queue" do
+    story = Story.create :text => 'Once upon...'
+
+    expect { story.whatever_else(1, 5) }.to change { Delayed::Job.jobs_count(:current, "testqueue") }.by(1)
+
+    job = Delayed::Job.list_jobs(:current, 1, 0, "testqueue").first
+    job.payload_object.class.should   == Delayed::PerformableMethod
+    job.payload_object.method.should  == :whatever_else_without_send_later
+    job.payload_object.args.should    == [1, 5]
+    job.payload_object.perform.should == 'Once upon...'
+  end
+
+  context "send_later" do
+    it "should use the default queue if there is one" do
+      set_queue("testqueue") do
+        "string".send_later :reverse
+        job = Delayed::Job.list_jobs(:current, 1).first
+        job.queue.should == "testqueue"
+
+        "string".send_later :reverse, :queue => nil
+        job2 = Delayed::Job.list_jobs(:current, 2).last
+        job2.queue.should == "testqueue"
+      end
+    end
+
+    it "should require a queue" do
+      expect { set_queue(nil) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "send_at" do
+    it "should queue a new job" do
+      lambda do
+        "string".send_at(1.hour.from_now, :length)
+      end.should change { Delayed::Job.jobs_count(:future) }.by(1)
+    end
+    
+    it "should schedule the job in the future" do
+      time = 1.hour.from_now
+      "string".send_at(time, :length)
+      job = Delayed::Job.list_jobs(:future, 1).first
+      job.run_at.to_i.should == time.to_i
+    end
+    
+    it "should store payload as PerformableMethod" do
+      "string".send_at(1.hour.from_now, :count, 'r')
+      job = Delayed::Job.list_jobs(:future, 1).first
+      job.payload_object.class.should   == Delayed::PerformableMethod
+      job.payload_object.method.should  == :count
+      job.payload_object.args.should    == ['r']
+      job.payload_object.perform.should == 1
+    end
+    
+    it "should use the default queue if there is one" do
+      set_queue("testqueue") do
+        "string".send_at 1.hour.from_now, :reverse
+        job = Delayed::Job.list_jobs(:current, 1).first
+        job.queue.should == "testqueue"
+      end
+    end
+  end
+
+  context "send_at_with_queue" do
+    it "should queue a new job" do
+      lambda do
+        "string".send_at_with_queue(1.hour.from_now, :length, "testqueue")
+      end.should change { Delayed::Job.jobs_count(:future, "testqueue") }.by(1)
+    end
+    
+    it "should schedule the job in the future" do
+      time = 1.hour.from_now
+      "string".send_at_with_queue(time, :length, "testqueue")
+      job = Delayed::Job.list_jobs(:future, 1, 0, "testqueue").first
+      job.run_at.to_i.should == time.to_i
+    end
+    
+    it "should override the default queue" do
+      set_queue("default_queue") do
+        "string".send_at_with_queue(1.hour.from_now, :length, "testqueue")
+        job = Delayed::Job.list_jobs(:future, 1, 0, "testqueue").first
+        job.queue.should == "testqueue"
+      end
+    end
+    
+    it "should store payload as PerformableMethod" do
+      "string".send_at_with_queue(1.hour.from_now, :count, "testqueue", 'r')
+      job = Delayed::Job.list_jobs(:future, 1, 0, "testqueue").first
+      job.payload_object.class.should   == Delayed::PerformableMethod
+      job.payload_object.method.should  == :count
+      job.payload_object.args.should    == ['r']
+      job.payload_object.perform.should == 1
+    end
+  end
+
+  describe "send_later_unless_in_job" do
+    module UnlessInJob
+      @runs = 0
+      def self.runs; @runs; end
+
+      def self.run
+        @runs += 1
+      end
+
+      def self.run_later
+        self.send_later_unless_in_job :run
+      end
+    end
+
+    before do
+      UnlessInJob.class_eval { @runs = 0 }
+    end
+
+    it "should perform immediately if in job" do
+      UnlessInJob.send_later :run_later
+      job = Delayed::Job.list_jobs(:current, 1).first
+      job.invoke_job
+      UnlessInJob.runs.should == 1
+    end
+
+    it "should queue up for later if not in job" do
+      UnlessInJob.run_later
+      UnlessInJob.runs.should == 0
+    end
+  end
+
+end