inst-jobs 0.16.0 → 1.0.0

data/spec/gemfiles/60.gemfile.lock

@@ -0,0 +1,222 @@
+PATH
+  remote: ../..
+  specs:
+    inst-jobs (1.0.0)
+      activerecord (>= 4.2)
+      activesupport (>= 4.2)
+      after_transaction_commit (>= 1.0, < 3)
+      fugit (~> 1.3)
+      railties (>= 4.2)
+      redis (> 3.0)
+      redis-scripting (~> 1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (6.0.2)
+      actionpack (= 6.0.2)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (6.0.2)
+      actionpack (= 6.0.2)
+      activejob (= 6.0.2)
+      activerecord (= 6.0.2)
+      activestorage (= 6.0.2)
+      activesupport (= 6.0.2)
+      mail (>= 2.7.1)
+    actionmailer (6.0.2)
+      actionpack (= 6.0.2)
+      actionview (= 6.0.2)
+      activejob (= 6.0.2)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (6.0.2)
+      actionview (= 6.0.2)
+      activesupport (= 6.0.2)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (6.0.2)
+      actionpack (= 6.0.2)
+      activerecord (= 6.0.2)
+      activestorage (= 6.0.2)
+      activesupport (= 6.0.2)
+      nokogiri (>= 1.8.5)
+    actionview (6.0.2)
+      activesupport (= 6.0.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (6.0.2)
+      activesupport (= 6.0.2)
+      globalid (>= 0.3.6)
+    activemodel (6.0.2)
+      activesupport (= 6.0.2)
+    activerecord (6.0.2)
+      activemodel (= 6.0.2)
+      activesupport (= 6.0.2)
+    activestorage (6.0.2)
+      actionpack (= 6.0.2)
+      activejob (= 6.0.2)
+      activerecord (= 6.0.2)
+      marcel (~> 0.3.1)
+    activesupport (6.0.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2)
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    after_transaction_commit (2.2.0)
+      activerecord (>= 5.2)
+    backports (3.15.0)
+    builder (3.2.4)
+    bump (0.8.0)
+    byebug (11.0.1)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.7)
+    crass (1.0.6)
+    database_cleaner (1.6.1)
+    diff-lcs (1.3)
+    erubi (1.9.0)
+    et-orbi (1.2.4)
+      tzinfo
+    fugit (1.3.9)
+      et-orbi (~> 1.1, >= 1.1.8)
+      raabro (~> 1.3)
+    globalid (0.4.2)
+      activesupport (>= 4.2.0)
+    httpclient (2.8.3)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    imperium (0.5.2)
+      addressable (~> 2.5)
+      httpclient (~> 2.8)
+    loofah (2.7.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (0.3.3)
+      mimemagic (~> 0.3.2)
+    method_source (0.9.2)
+    mimemagic (0.3.5)
+    mini_mime (1.0.2)
+    mini_portile2 (2.4.0)
+    minitest (5.14.2)
+    multi_json (1.13.1)
+    mustermann (1.0.0.beta2)
+    nio4r (2.5.4)
+    nokogiri (1.10.10)
+      mini_portile2 (~> 2.4.0)
+    pg (0.21.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    public_suffix (4.0.6)
+    raabro (1.4.0)
+    rack (2.0.7)
+    rack-protection (2.0.0.beta2)
+      rack
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails (6.0.2)
+      actioncable (= 6.0.2)
+      actionmailbox (= 6.0.2)
+      actionmailer (= 6.0.2)
+      actionpack (= 6.0.2)
+      actiontext (= 6.0.2)
+      actionview (= 6.0.2)
+      activejob (= 6.0.2)
+      activemodel (= 6.0.2)
+      activerecord (= 6.0.2)
+      activestorage (= 6.0.2)
+      activesupport (= 6.0.2)
+      bundler (>= 1.3.0)
+      railties (= 6.0.2)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.3.0)
+      loofah (~> 2.3)
+    railties (6.0.2)
+      actionpack (= 6.0.2)
+      activesupport (= 6.0.2)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.20.3, < 2.0)
+    rake (12.3.3)
+    redis (4.2.2)
+    redis-scripting (1.0.1)
+      redis (>= 3.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    sinatra (2.0.0.beta2)
+      mustermann (= 1.0.0.beta2)
+      rack (~> 2.0)
+      rack-protection (= 2.0.0.beta2)
+      tilt (~> 2.0)
+    sinatra-contrib (2.0.0.beta2)
+      backports (>= 2.0)
+      multi_json
+      mustermann (= 1.0.0.beta2)
+      rack-protection (= 2.0.0.beta2)
+      rack-test
+      sinatra (= 2.0.0.beta2)
+      tilt (>= 1.3, < 3)
+    sprockets (4.0.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.2)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    thor (1.0.1)
+    thread_safe (0.3.6)
+    tilt (2.0.9)
+    timecop (0.7.1)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+    websocket-driver (0.7.3)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    wwtd (1.4.1)
+    zeitwerk (2.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bump
+  byebug
+  database_cleaner (= 1.6.1)
+  imperium (>= 0.5.2)
+  inst-jobs!
+  pg (< 1.0)
+  pry
+  rack-test
+  rails (~> 6.0.0)
+  rake
+  rspec (~> 3.8.0)
+  sinatra (= 2.0.0.beta2)
+  sinatra-contrib (= 2.0.0.beta2)
+  timecop (= 0.7.1)
+  wwtd (~> 1.4.0)
+
+BUNDLED WITH
+   2.1.2

data/spec/migrate/20140924140513_add_story_table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddStoryTable < ActiveRecord::Migration[4.2]
   def change
     create_table :stories do |table|

data/spec/redis_job_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path("../spec_helper", __FILE__)
 
 describe 'Delayed::Backend::Redis::Job' do
@@ -18,8 +20,8 @@ describe 'Delayed::Backend::Redis::Job' do
   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)
+      3.times { jobs << "test".delay(ignore_transaction: true, strand: "s1").to_s }
+      job = "test".delay(strand: "s1", ignore_transaction: true).to_s
       # 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
@@ -29,8 +31,8 @@ describe 'Delayed::Backend::Redis::Job' do
 
     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)
+      3.times { jobs << "test".delay(strand: "s1", ignore_transaction: true).to_s }
+      job = "test".delay(strand: "s1", ignore_transaction: true).to_s
       # 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
@@ -44,8 +46,8 @@ describe 'Delayed::Backend::Redis::Job' do
 
   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)
+      @job = "test".delay(ignore_transaction: true).to_s
+      @job2 = "test".delay(ignore_transaction: true).to_s
       # manually delete the job from redis
       Delayed::Job.redis.del(Delayed::Job::Keys::JOB[@job.id])
     end
@@ -63,11 +65,11 @@ describe 'Delayed::Backend::Redis::Job' do
     end
   end
 
-  describe "send_later" do
+  describe "delay" 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 = "string".delay.reverse
         job.should be_nil
         Delayed::Job.jobs_count(:current).should == before_count
       end

data/spec/sample_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SimpleJob
   cattr_accessor :runs; self.runs = 0
   def perform; @@runs += 1; end

data/spec/shared/delayed_batch.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 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
+        "string".delay(ignore_transaction: true).size.should be true
+        "string".delay(run_at: later, ignore_transaction: true).reverse.should be_truthy # won't be batched, it'll get its own job
+        "string".delay(ignore_transaction: true).gsub(/./, "!").should be_truthy
       }
       batch_jobs = Delayed::Job.find_available(5)
       regular_jobs = Delayed::Job.list_jobs(:future, 5)
@@ -24,8 +26,8 @@ shared_examples_for 'Delayed::Batch' do
     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
+        "string".delay(ignore_transaction: true).size.should be true
+        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
       }
       Delayed::Job.jobs_count(:current).should == 1
       job = Delayed::Job.find_available(1).first
@@ -34,8 +36,8 @@ shared_examples_for 'Delayed::Batch' do
 
     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
+        "string".delay(ignore_transaction: true).size.should be true
+        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
       }
       Delayed::Job.jobs_count(:current).should == 1
 
@@ -58,16 +60,16 @@ shared_examples_for 'Delayed::Batch' do
     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
+        "string".delay(priority: Delayed::LOW_PRIORITY, ignore_transaction: true).size.should be true
+        "string".delay(ignore_transaction: true).gsub(/./, "!").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
+        "string".delay(priority: 20, ignore_transaction: true).size.should be true
+        "string".delay(priority: 15, ignore_transaction: true).gsub(/./, "!").should be true
       }
       Delayed::Job.jobs_count(:current).should == 1
       Delayed::Job.find_available(1).first.priority.should == 11
@@ -75,7 +77,7 @@ shared_examples_for 'Delayed::Batch' do
 
     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
+        "string".delay(ignore_transaction: true).size.should be true
       }
       Delayed::Job.jobs_count(:current).should == 1
       Delayed::Job.find_available(1).first.tag.should == "String#size"
@@ -84,9 +86,9 @@ shared_examples_for 'Delayed::Batch' do
 
     it "should list a job only once when the same call is made multiple times" do
       Delayed::Batch.serial_batch(:priority => 11) {
-        "string".send_later_enqueue_args(:size, no_delay: true)
-        "string".send_later_enqueue_args(:gsub, { no_delay: true }, /./, "!")
-        "string".send_later_enqueue_args(:size, no_delay: true)
+        "string".delay(ignore_transaction: true).size
+        "string".delay(ignore_transaction: true).gsub(/./, "!")
+        "string".delay(ignore_transaction: true).size
       }
       batch_job = Delayed::Job.find_available(1).first
       jobs = batch_job.payload_object.jobs

data/spec/shared/delayed_method.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'random ruby objects' do
   def set_queue(name)
     old_name = Delayed::Settings.queue
@@ -6,42 +8,42 @@ shared_examples_for 'random ruby objects' do
     Delayed::Settings.queue = old_name
   end
 
-  it "should respond_to :send_later method" do
-    Object.new.respond_to?(:send_later)
+  it "should respond_to :delay method" do
+    Object.new.respond_to?(:delay)
   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)
+  it "should raise a ArgumentError if delay is called but the target method doesn't exist" do
+    lambda { Object.new.delay.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)
+  it "should add a new entry to the job table when delay is called on it" do
+    lambda { Object.new.delay.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)
+  it "should add a new entry to the job table when delay is called on it with a queue" do
+    lambda { Object.new.delay(queue: "testqueue").to_s }.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)
+  it "should add a new entry to the job table when delay is called on the class" do
+    lambda { Object.delay.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)
+  it "should add a new entry to the job table when delay is called on the class with a queue" do
+    lambda { Object.delay(queue: "testqueue").to_s }.should change { Delayed::Job.jobs_count(:current, "testqueue") }.by(1)
   end
 
   context "class methods" do
-    context "add_send_later_methods" do
+    context "handle_asynchronously" do
       it "should work with default_async" do
         klass = Class.new do
           attr_reader :ran
           def test_method; @ran = true; end
-          add_send_later_methods :test_method, {}, true
+          handle_asynchronously :test_method
         end
         obj = klass.new
         lambda { obj.test_method }.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) }
+        lambda { obj.test_method(synchronous: true) }.should_not change { Delayed::Job.jobs_count(:current) }
         obj.ran.should be true
       end
 
@@ -49,7 +51,7 @@ shared_examples_for 'random ruby objects' do
         klass = Class.new do
           attr_reader :ran
           def test_method; @ran = true; end
-          add_send_later_methods :test_method, {singleton: -> (obj) { "foobar:#{obj.object_id}" }}, true
+          handle_asynchronously :test_method, singleton: -> (obj) { "foobar:#{obj.object_id}" }
         end
 
         obj = klass.new
@@ -60,10 +62,10 @@ shared_examples_for 'random ruby objects' do
         klass = Class.new do
           attr_reader :run
           def test_method(my_kwarg: nil); @run = my_kwarg; end
-          add_send_later_methods :test_method
+          handle_asynchronously :test_method
 
           def other_test(arg); @foo = arg; end
-          add_send_later_methods :other_test
+          handle_asynchronously :other_test
         end
 
         obj = klass.new
@@ -71,117 +73,74 @@ shared_examples_for 'random ruby objects' do
         expect(obj.run).to eq 'foo'
       end
 
-      it "should work without default_async" do
-        klass = Class.new do
-          attr_accessor :ran
-          def test_method; @ran = true; end
-          add_send_later_methods :test_method, {}, false
-        end
-        obj = klass.new
-        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
+      it "should send along enqueue args and args" do
         klass = Class.new do
           attr_accessor :ran
           def test_method(*args); @ran = args; end
-          add_send_later_methods(:test_method, {:enqueue_arg_1 => :thing}, true)
+          handle_asynchronously(:test_method, enqueue_arg_1: :thing)
         end
         obj = klass.new
         method = double()
 
-        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, [1,2,3, {synchronous: true}], nil, nil).and_return(method)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, args: [1,2,3], kwargs: {synchronous: true}, on_failure: nil, on_permanent_failure: nil).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, [4, {:synchronous=>true}], nil, nil).and_return(method)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, args: [4], kwargs: {:synchronous=>true}, on_failure: nil, on_permanent_failure: nil).and_return(method)
         expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
         obj.test_method(4)
 
         obj.ran.should be_nil
-        obj.test_method_without_send_later(7)
+        obj.test_method(7, synchronous: true)
         obj.ran.should == [7]
         obj.ran = nil
         obj.ran.should == nil
-        obj.test_method_without_send_later(8,9)
+        obj.test_method(8,9, synchronous: true)
         obj.ran.should == [8,9]
       end
 
-      it "should handle punctuation correctly with default_async" do
+      it "should handle punctuation correctly" do
         klass = Class.new do
           attr_reader :ran
           def test_method?; @ran = true; end
-          add_send_later_methods :test_method?, {}, true
+          handle_asynchronously :test_method?
         end
         obj = klass.new
         lambda { obj.test_method? }.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
-        klass = Class.new do
-          attr_accessor :ran
-          def test_method?; @ran = true; end
-          add_send_later_methods :test_method?, {}, false
-        end
-        obj = klass.new
-        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) }
+        lambda { obj.test_method?(synchronous: true) }.should_not change { Delayed::Job.jobs_count(:current) }
         obj.ran.should be true
       end
 
-      it "should handle assignment punctuation correctly with default_async" do
+      it "should handle assignment punctuation correctly" do
         klass = Class.new do
           attr_reader :ran
           def test_method=(val); @ran = val; end
-          add_send_later_methods :test_method=, {}, true
+          handle_asynchronously :test_method=
         end
         obj = klass.new
         lambda { obj.test_method = 3 }.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) }
+        lambda { obj.send(:test_method=, 5, synchronous: true) }.should_not change { Delayed::Job.jobs_count(:current) }
         obj.ran.should == 5
       end
 
-      it "should handle assignment punctuation correctly without default_async" do
-        klass = Class.new do
-          attr_accessor :ran
-          def test_method=(val); @ran = val; end
-          add_send_later_methods :test_method=, {}, false
-        end
-        obj = klass.new
-        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
+      it "should correctly sort out method accessibility" do
         klass1 = Class.new do
           def test_method; end
-          add_send_later_methods :test_method, {}, true
+          handle_asynchronously :test_method
         end
 
         klass2 = Class.new do
           protected
           def test_method; end
-          add_send_later_methods :test_method, {}, true
+          handle_asynchronously :test_method
         end
 
         klass3 = Class.new do
           private
           def test_method; end
-          add_send_later_methods :test_method, {}, true
+          handle_asynchronously :test_method
         end
 
         klass1.public_method_defined?(:test_method).should be true
@@ -189,77 +148,6 @@ shared_examples_for 'random ruby objects' do
         klass3.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
@@ -270,30 +158,19 @@ shared_examples_for 'random ruby objects' do
     job = Delayed::Job.list_jobs(:current, 1).first
     job.payload_object.class.should   == Delayed::PerformableMethod
     job.payload_object.method.should  == :whatever
-    job.payload_object.args.should    == [1, 5, {:synchronous=>true}]
-    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
-    job.payload_object.args.should    == [1, 5, {:synchronous=>true}]
+    job.payload_object.args.should    == [1, 5]
+    job.payload_object.kwargs.should  == {:synchronous=>true}
     job.payload_object.perform.should == 'Once upon...'
   end
 
-  context "send_later" do
+  context "delay" do
     it "should use the default queue if there is one" do
       set_queue("testqueue") do
-        "string".send_later :reverse
+        "string".delay.reverse
         job = Delayed::Job.list_jobs(:current, 1).first
         job.queue.should == "testqueue"
 
-        "string".send_later :reverse, :queue => nil
+        "string".delay(queue: nil).reverse
         job2 = Delayed::Job.list_jobs(:current, 2).last
         job2.queue.should == "testqueue"
       end
@@ -304,22 +181,22 @@ shared_examples_for 'random ruby objects' do
     end
   end
 
-  context "send_at" do
+  context "delay with run_at" do
     it "should queue a new job" do
       lambda do
-        "string".send_at(1.hour.from_now, :length)
+        "string".delay(run_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)
+      "string".delay(run_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')
+      "string".delay(run_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
@@ -329,46 +206,14 @@ shared_examples_for 'random ruby objects' do
 
     it "should use the default queue if there is one" do
       set_queue("testqueue") do
-        "string".send_at 1.hour.from_now, :reverse
+        "string".delay(run_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
+  describe "delay with synchronous argument" do
     module UnlessInJob
       @runs = 0
       def self.runs; @runs; end
@@ -378,7 +223,7 @@ shared_examples_for 'random ruby objects' do
       end
 
       def self.run_later
-        self.send_later_unless_in_job :run
+        self.delay(synchronous: Delayed::Job.in_delayed_job?).run
       end
     end
 
@@ -387,7 +232,7 @@ shared_examples_for 'random ruby objects' do
     end
 
     it "should perform immediately if in job" do
-      UnlessInJob.send_later :run_later
+      UnlessInJob.delay.run_later
       job = Delayed::Job.list_jobs(:current, 1).first
       job.invoke_job
       UnlessInJob.runs.should == 1