delayed 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6690016ceeb6764ea0d848c7b8f065f1c5c7587b1a6f519f81f90131c2a77c30
-  data.tar.gz: 83dc7b900584296c9c383ca5171f087da2c71cbbc44e5dca1898e03e2716ab6f
+  metadata.gz: 6a1cf38e09aa1495cf90b772f2ea4168497b2f1d819af54f1bf23644e591f021
+  data.tar.gz: 992f2c890116bb021368b4317d3d65aa37ac5c72627dc4d78e1815bb70b16fdf
 SHA512:
-  metadata.gz: d39684e6f3d1fafff2ee632ec243ca5e387f30fa970125f16c456410c5a69ea25fcf906b61d7015e53e40743f9d76133f3054c3fcb781c381c46ea9454d44d42
-  data.tar.gz: '08f057ac20053b5e7a04c98a5b14214ebf43ff0056798a456229482303057c7a68eb08d84d4724d0c3058348ec04d9a3f08db9f1bc5f2dd4528de9161e405ddb'
+  metadata.gz: 6f24864e443ddf7f964be5bdf1f25fb1be789f8f19801b31a922fd4c18884bef412255c37676fa57813e96cca0a29299dfe620265ce6ff515351af70dd632ceb
+  data.tar.gz: ad160c352e49f6c5e75ddd1eea94bba65998bb291e8bb6a8c9815ec8387e1871f4acb7cd854abaaa450641598e70b05779e872ba0de8c992c3bf47401f5a1b9a

data/lib/delayed/active_job_adapter.rb

@@ -56,6 +56,10 @@ module Delayed
       end
     end
 
+    def encode_with(coder)
+      coder['job_data'] = @job_data
+    end
+
     private
 
     def job

data/lib/delayed/message_sending.rb

@@ -8,8 +8,8 @@ module Delayed
       @options = options
     end
 
-    def method_missing(method, *args)
-      Job.enqueue({ payload_object: @payload_class.new(@target, method.to_sym, args) }.merge(@options))
+    def method_missing(method, *args, **kwargs)
+      Job.enqueue({ payload_object: @payload_class.new(@target, method.to_sym, args, kwargs) }.merge(@options))
     end
   end
 
@@ -18,16 +18,6 @@ module Delayed
       DelayProxy.new(PerformableMethod, self, options)
     end
     alias __delay__ delay
-
-    def send_later(method, *args)
-      warn '[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method'
-      __delay__.__send__(method, *args)
-    end
-
-    def send_at(time, method, *args)
-      warn '[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method'
-      __delay__(run_at: time).__send__(method, *args)
-    end
   end
 
   module MessageSendingClassMethods
@@ -36,7 +26,7 @@ module Delayed
       punctuation = $1 # rubocop:disable Style/PerlBackrefs
       with_method = "#{aliased_method}_with_delay#{punctuation}"
       without_method = "#{aliased_method}_without_delay#{punctuation}"
-      define_method(with_method) do |*args|
+      define_method(with_method) do |*args, **kwargs|
         curr_opts = opts.clone
         curr_opts.each_key do |key|
           next unless (val = curr_opts[key]).is_a?(Proc)
@@ -47,7 +37,7 @@ module Delayed
                              val.call
                            end
         end
-        delay(curr_opts).__send__(without_method, *args)
+        delay(curr_opts).__send__(without_method, *args, **kwargs)
       end
 
       alias_method without_method, method

data/lib/delayed/performable_mailer.rb

@@ -3,7 +3,7 @@ require 'mail'
 module Delayed
   class PerformableMailer < PerformableMethod
     def perform
-      mailer = object.send(method_name, *args)
+      mailer = super
       mailer.respond_to?(:deliver_now) ? mailer.deliver_now : mailer.deliver
     end
   end

data/lib/delayed/performable_method.rb

@@ -1,8 +1,8 @@
 module Delayed
   class PerformableMethod
-    attr_accessor :object, :method_name, :args
+    attr_accessor :object, :method_name, :args, :kwargs
 
-    def initialize(object, method_name, args)
+    def initialize(object, method_name, args, kwargs)
       raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
 
       if !her_model?(object) && object.respond_to?(:persisted?) && !object.persisted?
@@ -11,6 +11,7 @@ module Delayed
 
       self.object       = object
       self.args         = args
+      self.kwargs       = kwargs
       self.method_name  = method_name.to_sym
     end
 
@@ -23,7 +24,13 @@ module Delayed
     end
 
     def perform
-      object.send(method_name, *args) if object
+      return unless object
+
+      if kwargs.nil? || (RUBY_VERSION < '2.7' && kwargs.empty?)
+        object.send(method_name, *args)
+      else
+        object.send(method_name, *args, **kwargs)
+      end
     end
 
     def method(sym)

data/lib/delayed/psych_ext.rb

@@ -6,6 +6,7 @@ module Delayed
         'object' => object,
         'method_name' => method_name,
         'args' => args,
+        'kwargs' => kwargs,
       }
     end
   end

data/spec/delayed/active_job_adapter_spec.rb

@@ -23,6 +23,40 @@ RSpec.describe Delayed::ActiveJobAdapter do
     ActiveJob::Base.queue_adapter = adapter_was
   end
 
+  it 'serializes a JobWrapper in the handler with expected fields' do
+    Timecop.freeze('2023-01-20T18:52:29Z') do
+      JobClass.perform_later
+    end
+
+    Delayed::Job.last.tap do |dj|
+      expect(dj.handler.lines).to match [
+        "--- !ruby/object:Delayed::JobWrapper\n",
+        "job_data:\n",
+        "  job_class: JobClass\n",
+        /  job_id: '?#{dj.payload_object.job_id}'?\n/,
+        "  provider_job_id: \n",
+        "  queue_name: default\n",
+        "  priority: \n",
+        "  arguments: []\n",
+        "  executions: 0\n",
+        ("  exception_executions: {}\n" if ActiveJob::VERSION::MAJOR >= 6),
+        "  locale: en\n",
+        ("  timezone: \n" if ActiveJob::VERSION::MAJOR >= 6),
+        ("  enqueued_at: '2023-01-20T18:52:29Z'\n" if ActiveJob::VERSION::MAJOR >= 6),
+      ].compact
+    end
+  end
+
+  it 'deserializes even if the underlying job class is not defined' do
+    JobClass.perform_later
+
+    Delayed::Job.last.tap do |dj|
+      dj.handler = dj.handler.gsub('JobClass', 'MissingJobClass')
+      expect { dj.payload_object }.not_to raise_error
+      expect { dj.payload_object.job_id }.to raise_error(NameError, 'uninitialized constant MissingJobClass')
+    end
+  end
+
   describe '.set' do
     it 'supports priority as an integer' do
       JobClass.set(priority: 43).perform_later
@@ -223,6 +257,25 @@ RSpec.describe Delayed::ActiveJobAdapter do
       end
     end
 
+    context 'when ActiveJob has both positional and keyword arguments' do
+      let(:job_class) do
+        Class.new(ActiveJob::Base) do # rubocop:disable Rails/ApplicationJob
+          cattr_accessor(:result)
+
+          def perform(arg, kwarg:)
+            self.class.result = [arg, kwarg]
+          end
+        end
+      end
+
+      it 'passes arguments through to the perform method' do
+        JobClass.perform_later('foo', kwarg: 'bar')
+
+        Delayed::Worker.new.work_off
+        expect(JobClass.result).to eq %w(foo bar)
+      end
+    end
+
     context 'when using the ActiveJob test adapter' do
       let(:queue_adapter) { :test }
 

data/spec/delayed/job_spec.rb

@@ -352,7 +352,7 @@ describe Delayed::Job do
   context 'large handler' do
     before do
       text = 'Lorem ipsum dolor sit amet. ' * 1000
-      @job = described_class.enqueue Delayed::PerformableMethod.new(text, :length, {})
+      @job = described_class.enqueue Delayed::PerformableMethod.new(text, :length, [], {})
     end
 
     it 'has an id' do

data/spec/message_sending_spec.rb

@@ -7,24 +7,27 @@ describe Delayed::MessageSending do
   end
 
   describe 'handle_asynchronously' do
-    class Story
-      def tell!(_arg); end
-      handle_asynchronously :tell!
+    let(:test_class) do
+      Class.new do
+        def tell!(_arg, _kwarg:); end
+        handle_asynchronously :tell!
+      end
     end
 
     it 'aliases original method' do
-      expect(Story.new).to respond_to(:tell_without_delay!)
-      expect(Story.new).to respond_to(:tell_with_delay!)
+      expect(test_class.new).to respond_to(:tell_without_delay!)
+      expect(test_class.new).to respond_to(:tell_with_delay!)
     end
 
     it 'creates a PerformableMethod' do
-      story = Story.create
+      obj = test_class.new
       expect {
-        job = story.tell!(1)
+        job = obj.tell!('a', kwarg: 'b')
         expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
         expect(job.payload_object.method_name).to eq(:tell_without_delay!)
-        expect(job.payload_object.args).to eq([1])
-      }.to(change { Delayed::Job.count })
+        expect(job.payload_object.args).to eq(['a'])
+        expect(job.payload_object.kwargs).to eq(kwarg: 'b')
+      }.to change { Delayed::Job.count }.by(1)
     end
 
     describe 'with options' do
@@ -64,26 +67,33 @@ describe Delayed::MessageSending do
   end
 
   context 'delay' do
-    class FairyTail
-      attr_accessor :happy_ending
+    let(:fairy_tail_class) do
+      Class.new do
+        attr_accessor :happy_ending
 
-      def self.princesses; end
+        def self.princesses; end
 
-      def tell
-        @happy_ending = true
+        def tell(arg, kwarg:)
+          @happy_ending = [arg, kwarg]
+        end
       end
     end
 
+    before do
+      stub_const('FairyTail', fairy_tail_class)
+    end
+
     after do
       Delayed::Worker.default_queue_name = nil
     end
 
     it 'creates a new PerformableMethod job' do
       expect {
-        job = 'hello'.delay.count('l')
+        job = FairyTail.new.delay.tell('arg', kwarg: 'kwarg')
         expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
-        expect(job.payload_object.method_name).to eq(:count)
-        expect(job.payload_object.args).to eq(['l'])
+        expect(job.payload_object.method_name).to eq(:tell)
+        expect(job.payload_object.args).to eq(['arg'])
+        expect(job.payload_object.kwargs).to eq(kwarg: 'kwarg')
       }.to change { Delayed::Job.count }.by(1)
     end
 
@@ -111,8 +121,8 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
-        }.to change { fairy_tail.happy_ending }.from(nil).to(true)
+          fairy_tail.delay.tell('a', kwarg: 'b')
+        }.to change { fairy_tail.happy_ending }.from(nil).to %w(a b)
       }.not_to(change { Delayed::Job.count })
     end
 
@@ -121,7 +131,7 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
+          fairy_tail.delay.tell('a', kwarg: 'b')
         }.not_to change { fairy_tail.happy_ending }
       }.to change { Delayed::Job.count }.by(1)
     end
@@ -131,7 +141,7 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
+          fairy_tail.delay.tell('a', kwarg: 'b')
         }.not_to change { fairy_tail.happy_ending }
       }.to change { Delayed::Job.count }.by(1)
     end
@@ -141,8 +151,8 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
-        }.to change { fairy_tail.happy_ending }.from(nil).to(true)
+          fairy_tail.delay.tell('a', kwarg: 'b')
+        }.to change { fairy_tail.happy_ending }.from(nil).to %w(a b)
       }.not_to(change { Delayed::Job.count })
     end
   end

data/spec/performable_mailer_spec.rb

@@ -1,58 +1,41 @@
 require 'helper'
 
-class MyMailer < ActionMailer::Base
-  def signup(email)
-    mail to: email, subject: 'Delaying Emails', from: 'delayedjob@example.com', body: 'Delaying Emails Body'
-  end
-end
+describe Delayed::PerformableMailer do
+  let(:mailer_class) do
+    Class.new(ActionMailer::Base) do
+      cattr_accessor(:emails) { [] }
 
-describe ActionMailer::Base do
-  describe 'delay' do
-    it 'enqueues a PerformableEmail job' do
-      expect {
-        job = MyMailer.delay.signup('john@example.com')
-        expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
-        expect(job.payload_object.method_name).to eq(:signup)
-        expect(job.payload_object.args).to eq(['john@example.com'])
-      }.to change { Delayed::Job.count }.by(1)
+      def signup(email, beta_tester: false)
+        mail to: email, subject: "Delaying Emails (beta: #{beta_tester})", from: 'delayedjob@example.com', body: 'Delaying Emails Body'
+      end
     end
   end
 
-  describe 'delay on a mail object' do
-    it 'raises an exception' do
-      expect {
-        MyMailer.signup('john@example.com').delay
-      }.to raise_error(RuntimeError)
-    end
+  before do
+    stub_const('MyMailer', mailer_class)
   end
 
-  describe Delayed::PerformableMailer do
-    describe 'perform' do
-      it 'calls the method and #deliver on the mailer' do
-        email = double('email', deliver: true)
-        mailer_class = double('MailerClass', signup: email)
-        mailer = described_class.new(mailer_class, :signup, ['john@example.com'])
+  describe 'perform' do
+    it 'calls the method and #deliver on the mailer' do
+      mailer = MyMailer.new
+      email = double('email', deliver: true)
+      allow(mailer).to receive(:mail).and_return(email)
+      mailer_job = described_class.new(mailer, :signup, ['john@example.com'], {})
 
-        expect(mailer_class).to receive(:signup).with('john@example.com')
-        expect(email).to receive(:deliver)
-        mailer.perform
-      end
+      expect(email).to receive(:deliver)
+      mailer_job.perform
     end
   end
-end
 
-if defined?(ActionMailer::Parameterized::Mailer)
-  describe ActionMailer::Parameterized::Mailer do
+  describe ActionMailer::Base do
     describe 'delay' do
       it 'enqueues a PerformableEmail job' do
         expect {
-          job = MyMailer.with(foo: 1, bar: 2).delay.signup('john@example.com')
+          job = MyMailer.delay.signup('john@example.com', beta_tester: true)
           expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
-          expect(job.payload_object.object.class).to eq(described_class)
-          expect(job.payload_object.object.instance_variable_get('@mailer')).to eq(MyMailer)
-          expect(job.payload_object.object.instance_variable_get('@params')).to eq(foo: 1, bar: 2)
           expect(job.payload_object.method_name).to eq(:signup)
           expect(job.payload_object.args).to eq(['john@example.com'])
+          expect(job.payload_object.kwargs).to eq(beta_tester: true)
         }.to change { Delayed::Job.count }.by(1)
       end
     end
@@ -60,9 +43,36 @@ if defined?(ActionMailer::Parameterized::Mailer)
     describe 'delay on a mail object' do
       it 'raises an exception' do
         expect {
-          MyMailer.with(foo: 1, bar: 2).signup('john@example.com').delay
+          MyMailer.signup('john@example.com').delay
         }.to raise_error(RuntimeError)
       end
     end
   end
+
+  if defined?(ActionMailer::Parameterized::Mailer)
+    describe ActionMailer::Parameterized::Mailer do
+      describe 'delay' do
+        it 'enqueues a PerformableEmail job' do
+          expect {
+            job = MyMailer.with(foo: 1, bar: 2).delay.signup('john@example.com', beta_tester: false)
+            expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
+            expect(job.payload_object.object.class).to eq(described_class)
+            expect(job.payload_object.object.instance_variable_get(:@mailer)).to eq(MyMailer)
+            expect(job.payload_object.object.instance_variable_get(:@params)).to eq(foo: 1, bar: 2)
+            expect(job.payload_object.method_name).to eq(:signup)
+            expect(job.payload_object.args).to eq(['john@example.com'])
+            expect(job.payload_object.kwargs).to eq(beta_tester: false)
+          }.to change { Delayed::Job.count }.by(1)
+        end
+      end
+
+      describe 'delay on a mail object' do
+        it 'raises an exception' do
+          expect {
+            MyMailer.with(foo: 1, bar: 2).signup('john@example.com').delay
+          }.to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
 end

data/spec/performable_method_spec.rb

@@ -2,8 +2,18 @@ require 'helper'
 
 describe Delayed::PerformableMethod do
   describe 'perform' do
+    let(:test_class) do
+      Class.new do
+        cattr_accessor :result
+
+        def foo(arg, kwarg:)
+          self.class.result = [arg, kwarg]
+        end
+      end
+    end
+
     before do
-      @method = described_class.new('foo', :count, ['o'])
+      @method = described_class.new(test_class.new, :foo, ['a'], { kwarg: 'b' })
     end
 
     context 'with the persisted record cannot be found' do
@@ -17,14 +27,29 @@ describe Delayed::PerformableMethod do
     end
 
     it 'calls the method on the object' do
-      expect(@method.object).to receive(:count).with('o')
-      @method.perform
+      expect { @method.perform }
+        .to change { test_class.result }
+        .from(nil).to %w(a b)
+    end
+
+    if RUBY_VERSION < '3.0'
+      context 'when kwargs are nil (job was delayed via prior gem version)' do
+        before do
+          @method = described_class.new(test_class.new, :foo, ['a', { kwarg: 'b' }], nil)
+        end
+
+        it 'calls the method on the object' do
+          expect { @method.perform }
+            .to change { test_class.result }
+            .from(nil).to %w(a b)
+        end
+      end
     end
   end
 
   it "raises a NoMethodError if target method doesn't exist" do
     expect {
-      described_class.new(Object, :method_that_does_not_exist, [])
+      described_class.new(Object, :method_that_does_not_exist, [], {})
     }.to raise_error(NoMethodError)
   end
 
@@ -33,29 +58,29 @@ describe Delayed::PerformableMethod do
       def private_method; end
       private :private_method
     end
-    expect { described_class.new(clazz.new, :private_method, []) }.not_to raise_error
+    expect { described_class.new(clazz.new, :private_method, [], {}) }.not_to raise_error
   end
 
   context 'when it receives an object that is not persisted' do
     let(:object) { double(persisted?: false, expensive_operation: true) }
 
     it 'raises an ArgumentError' do
-      expect { described_class.new(object, :expensive_operation, []) }.to raise_error ArgumentError
+      expect { described_class.new(object, :expensive_operation, [], {}) }.to raise_error ArgumentError
     end
 
     it 'does not raise ArgumentError if the object acts like a Her model' do
       allow(object.class).to receive(:save_existing).and_return(true)
-      expect { described_class.new(object, :expensive_operation, []) }.not_to raise_error
+      expect { described_class.new(object, :expensive_operation, [], {}) }.not_to raise_error
     end
   end
 
   describe 'display_name' do
     it 'returns class_name#method_name for instance methods' do
-      expect(described_class.new('foo', :count, ['o']).display_name).to eq('String#count')
+      expect(described_class.new('foo', :count, ['o'], {}).display_name).to eq('String#count')
     end
 
     it 'returns class_name.method_name for class methods' do
-      expect(described_class.new(Class, :inspect, []).display_name).to eq('Class.inspect')
+      expect(described_class.new(Class, :inspect, [], {}).display_name).to eq('Class.inspect')
     end
   end
 
@@ -84,7 +109,7 @@ describe Delayed::PerformableMethod do
     end
 
     it 'delegates failure hook to object' do
-      method = described_class.new('object', :size, [])
+      method = described_class.new('object', :size, [], {})
       expect(method.object).to receive(:failure)
       method.failure
     end
@@ -114,7 +139,7 @@ describe Delayed::PerformableMethod do
       end
 
       it 'delegates failure hook to object' do
-        method = described_class.new('object', :size, [])
+        method = described_class.new('object', :size, [], {})
         expect(method.object).to receive(:failure)
         method.failure
       end

data/spec/psych_ext_spec.rb

@@ -11,6 +11,30 @@ describe 'Psych::Visitors::ToRuby', if: defined?(Psych::Visitors::ToRuby) do
     end
   end
 
+  context Delayed::PerformableMethod do
+    it 'serializes with object, method_name, args, and kwargs' do
+      Delayed::PerformableMethod.new(String, :new, ['hello'], capacity: 20).tap do |pm|
+        serialized = YAML.dump_dj(pm)
+        expect(serialized).to eq <<~YAML
+          --- !ruby/object:Delayed::PerformableMethod
+          object: !ruby/class 'String'
+          method_name: :new
+          args:
+          - hello
+          kwargs:
+            :capacity: 20
+        YAML
+
+        deserialized = YAML.load_dj(serialized)
+        expect(deserialized).to be_an_instance_of(Delayed::PerformableMethod)
+        expect(deserialized.object).to eq String
+        expect(deserialized.method_name).to eq :new
+        expect(deserialized.args).to eq ['hello']
+        expect(deserialized.kwargs).to eq(capacity: 20)
+      end
+    end
+  end
+
   context ActiveRecord::Base do
     it 'serializes and deserializes in a version-independent way' do
       Story.create.tap do |story|

data/spec/worker_spec.rb

@@ -153,7 +153,7 @@ describe Delayed::Worker do
       expect(Delayed::Job).to receive(:reserve).exactly(10).times.and_raise(Exception)
       worker = described_class.new
       9.times { worker.work_off }
-      expect(lambda { worker.work_off }).to raise_exception Delayed::FatalBackendError
+      expect { worker.work_off }.to raise_exception Delayed::FatalBackendError
     end
 
     it 'allows the backend to attempt recovery from reservation errors' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Nathan Griffith
@@ -19,7 +19,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-26 00:00:00.000000000 Z
+date: 2023-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -290,6 +290,7 @@ metadata:
   changelog_uri: https://github.com/betterment/delayed/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/betterment/delayed/issues
   source_code_uri: https://github.com/betterment/delayed
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -305,7 +306,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: a multi-threaded, SQL-driven ActiveJob backend used at Betterment to process