activejob-retry 0.0.1 → 0.1.1

data/spec/retry_spec.rb

@@ -1,228 +1,172 @@
 require 'spec_helper'
 
 RSpec.describe ActiveJob::Retry do
-  subject(:job) { Class.new(ActiveJob::Base) { include ActiveJob::Retry } }
+  subject(:job) do
+    Class.new(ActiveJob::Base) do
+      include ActiveJob::Retry
 
-  describe '.retry_with' do
-    context 'valid options' do
-      before { job.retry_with(options) }
-
-      context 'limit only' do
-        context 'infinite retries' do
-          let(:options) { { limit: -1, infinite_job: true } }
-          its(:retry_limit) { is_expected.to eq(-1) }
-        end
-
-        context 'no retries' do
-          let(:options) { { limit: 0 } }
-          its(:retry_limit) { is_expected.to eq(0) }
-        end
-
-        context 'some retries' do
-          let(:options) { { limit: 3 } }
-          its(:retry_limit) { is_expected.to eq(3) }
-        end
-      end
-
-      context 'delay only' do
-        let(:options) { { delay: 0 } }
-        its(:retry_delay) { is_expected.to eq(0) }
-      end
-
-      context 'fatal exceptions' do
-        let(:options) { { fatal_exceptions: [RuntimeError] } }
-        its(:fatal_exceptions) { is_expected.to eq([RuntimeError]) }
-      end
-
-      context 'retry exceptions' do
-        let(:options) { { retry_exceptions: [StandardError, NoMethodError] } }
-        its(:retry_exceptions) { is_expected.to eq([StandardError, NoMethodError]) }
+      def perform(*_args)
+        raise RuntimeError
       end
+    end
+  end
 
-      context 'multiple options' do
-        let(:options) { { limit: 3, delay: 10, retry_exceptions: [RuntimeError] } }
-
-        its(:retry_limit) { is_expected.to eq(3) }
-        its(:retry_delay) { is_expected.to eq(10) }
-        its(:retry_exceptions) { is_expected.to eq([RuntimeError]) }
-      end
+  describe '.constant_retry' do
+    it 'sets a ConstantBackoffStrategy' do
+      job.constant_retry(limit: 10, delay: 5)
+      expect(job.backoff_strategy).to be_a(ActiveJob::Retry::ConstantBackoffStrategy)
     end
 
     context 'invalid options' do
-      subject { -> { job.retry_with(options) } }
-
-      context 'bad limit' do
-        let(:options) { { limit: -2 } }
-        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
-      end
-
-      context 'accidental infinite limit' do
-        let(:options) { { limit: -1 } }
-        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
-      end
-
-      context 'bad delay' do
-        let(:options) { { delay: -1 } }
-        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
-      end
+      let(:options) { { limit: -2 } }
 
-      context 'bad fatal exceptions' do
-        let(:options) { { fatal_exceptions: ['StandardError'] } }
-        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
-      end
-
-      context 'bad retry exceptions' do
-        let(:options) { { retry_exceptions: [:runtime] } }
-        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
-      end
-
-      context 'retry and fatal exceptions together' do
-        let(:options) { { fatal_exceptions: [StandardError], retry_exceptions: [] } }
-        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      specify do
+        expect { job.constant_retry(options) }.
+          to raise_error(ActiveJob::Retry::InvalidConfigurationError)
       end
     end
   end
 
-  describe '.retry_exception?' do
-    subject { job.retry_exception?(exception) }
-
-    context 'defaults (retry everything)' do
-      context 'Exception' do
-        let(:exception) { Exception.new }
-        it { is_expected.to be_truthy }
-      end
+  describe '.variable_retry' do
+    it 'sets a VariableBackoffStrategy' do
+      job.variable_retry(delays: [0, 5, 10, 60, 200])
+      expect(job.backoff_strategy).to be_a(ActiveJob::Retry::VariableBackoffStrategy)
+    end
 
-      context 'RuntimeError' do
-        let(:exception) { RuntimeError.new }
-        it { is_expected.to be_truthy }
-      end
+    context 'invalid options' do
+      let(:options) { {} }
 
-      context 'InvalidConfigurationError' do
-        let(:exception) { ActiveJob::Retry::InvalidConfigurationError.new }
-        it { is_expected.to be_truthy }
+      specify do
+        expect { job.variable_retry(options) }.
+          to raise_error(ActiveJob::Retry::InvalidConfigurationError)
       end
     end
+  end
 
-    context 'with whitelist' do
-      before { job.retry_with(retry_exceptions: [RuntimeError]) }
+  describe '.retry_with' do
+    it 'rejects invalid backoff strategies' do
+      expect { job.retry_with(Object.new) }.
+        to raise_error(ActiveJob::Retry::InvalidConfigurationError)
+    end
 
-      context 'Exception' do
-        let(:exception) { Exception.new }
-        it { is_expected.to be_falsey }
-      end
+    it 'sets the backoff_strategy when it is valid' do
+      module CustomBackoffStrategy
+        def self.should_retry?(_attempt, _exception)
+          true
+        end
 
-      context 'RuntimeError' do
-        let(:exception) { RuntimeError.new }
-        it { is_expected.to be_truthy }
+        def self.retry_delay(_attempt, _exception)
+          5
+        end
       end
 
-      context 'subclass of RuntimeError' do
-        let(:exception) { Class.new(RuntimeError).new }
-        it { is_expected.to be_truthy }
-      end
+      job.retry_with(CustomBackoffStrategy)
+      expect(job.backoff_strategy).to eq(CustomBackoffStrategy)
     end
+  end
 
-    context 'with blacklist' do
-      before { job.retry_with(fatal_exceptions: [RuntimeError]) }
+  describe '#serialize' do
+    let(:instance) { job.new }
+    subject { instance.serialize }
 
-      context 'Exception' do
-        let(:exception) { Exception.new }
-        it { is_expected.to be_truthy }
-      end
+    context 'first instantiated' do
+      it { is_expected.to include('retry_attempt' => 1) }
+    end
 
-      context 'RuntimeError' do
-        let(:exception) { RuntimeError.new }
-        it { is_expected.to be_falsey }
-      end
+    context '1st attempt' do
+      before { instance.instance_variable_set(:@retry_attempt, 1) }
+      it { is_expected.to include('retry_attempt' => 1) }
+    end
 
-      context 'subclass of RuntimeError' do
-        let(:exception) { Class.new(RuntimeError).new }
-        it { is_expected.to be_falsey }
-      end
+    context '7th attempt' do
+      before { instance.instance_variable_set(:@retry_attempt, 7) }
+      it { is_expected.to include('retry_attempt' => 7) }
     end
   end
 
-  describe '#retry_limit_reached?' do
-    let(:instance) { job.tap { |job| job.retry_with(options) }.new }
-    subject { instance.retry_limit_reached? }
-
-    context 'when the limit is infinite' do
-      let(:options) { { limit: -1, infinite_job: true } }
+  describe '#deserialize' do
+    subject(:instance) { job.new }
+    before { instance.deserialize(job_data) }
+    before { instance.send(:deserialize_arguments_if_needed) }
 
-      context 'first attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 1) }
-        it { is_expected.to be_falsey }
+    context '1st attempt' do
+      let(:job_data) do
+        {
+          'job_class'     => 'SomeJob',
+          'job_id'        => 'uuid',
+          'arguments'     => ['arg1', { 'arg' => 2 }],
+          'retry_attempt' => 1
+        }
       end
 
-      context '99999th attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 99999) }
-        it { is_expected.to be_falsey }
-      end
+      its(:job_id) { is_expected.to eq('uuid') }
+      its(:arguments) { is_expected.to eq(['arg1', { 'arg' => 2 }]) }
+      its(:retry_attempt) { is_expected.to eq(1) }
     end
 
-    context 'when the limit is 0' do
-      let(:options) { { limit: 0 } }
-
-      context 'first attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 1) }
-        it { is_expected.to be_truthy }
+    context '7th attempt' do
+      let(:job_data) do
+        {
+          'job_class'     => 'SomeJob',
+          'job_id'        => 'uuid',
+          'arguments'     => ['arg1', { 'arg' => 2 }],
+          'retry_attempt' => 7
+        }
       end
 
-      context '99999th attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 99999) }
-        it { is_expected.to be_truthy }
-      end
+      its(:job_id) { is_expected.to eq('uuid') }
+      its(:arguments) { is_expected.to eq(['arg1', { 'arg' => 2 }]) }
+      its(:retry_attempt) { is_expected.to eq(7) }
     end
+  end
 
-    context 'when the limit is 5' do
-      let(:options) { { limit: 5 } }
+  describe '#rescue_with_handler' do
+    let(:backoff_strategy) { described_class::ConstantBackoffStrategy.new(limit: 100) }
+    let(:instance) { job.new }
+    before { job.retry_with(backoff_strategy) }
+    subject(:perform) { instance.perform_now }
 
-      context 'first attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 1) }
-        it { is_expected.to be_falsey }
+    context 'when the job should be retried' do
+      before do
+        expect(backoff_strategy).to receive(:should_retry?).
+          with(1, instance_of(RuntimeError)).
+          and_return(true)
+        expect(backoff_strategy).to receive(:retry_delay).
+          with(1, instance_of(RuntimeError)).
+          and_return(5)
       end
 
-      context '4th attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 4) }
-        it { is_expected.to be_falsey }
+      it 'retries the job with the defined delay' do
+        expect(instance).to receive(:retry_job).with(hash_including(wait: 5))
+
+        perform
       end
 
-      context '5th attempt' do
-        before { instance.instance_variable_set(:@retry_attempt, 5) }
-        it { is_expected.to be_truthy }
+      it 'increases the retry_attempt count' do
+        perform
+        expect(instance.retry_attempt).to eq(2)
       end
-    end
-  end
 
-  describe '#retry_or_reraise' do
-    let(:instance) { job.new }
-    let(:exception) { RuntimeError.new }
-    subject(:retry_or_reraise) { instance.retry_or_reraise(exception) }
+      pending 'logs the retry' do
+        expect(ActiveJob::Base.logger).to receive(:log).
+          with(Logger::INFO, 'Retrying (attempt 1, waiting 0s)')
 
-    context 'when we should not retry' do
-      before do
-        allow(instance).to receive(:should_retry?).with(exception).and_return(false)
+        perform
       end
-
-      specify { expect { retry_or_reraise }.to raise_error(exception) }
     end
 
-    context 'when we should retry' do
+    context 'when the job should not be retried' do
       before do
-        allow(instance).to receive(:should_retry?).with(exception).and_return(true)
-        allow(instance).to receive(:retry_job).and_return(true)
+        expect(backoff_strategy).to receive(:should_retry?).
+          with(1, instance_of(RuntimeError)).
+          and_return(false)
       end
 
-      it 'logs the retry' do
-        expect(ActiveJob::Base.logger).to receive(:log).
-          with(Logger::INFO, 'Retrying (attempt 1)')
-        retry_or_reraise
-      end
+      it 'does not retry the job' do
+        expect(instance).to_not receive(:retry_job)
 
-      it 'retries the job' do
-        expect(instance).to receive(:retry_job).with(wait: 0)
-        retry_or_reraise
+        expect { perform }.to raise_error(RuntimeError)
       end
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
-require 'active_job-retry'
+require 'active_job/retry'
 require 'rspec/its'
-require 'pry'
+
+ActiveJob::Base.queue_adapter = :resque
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|

data/test/adapters/backburner.rb

@@ -0,0 +1,3 @@
+require 'support/backburner/inline'
+
+ActiveJob::Base.queue_adapter = :backburner

data/test/adapters/delayed_job.rb

@@ -0,0 +1,7 @@
+ActiveJob::Base.queue_adapter = :delayed_job
+
+$LOAD_PATH << File.dirname(__FILE__) + "/../support/delayed_job"
+
+Delayed::Worker.delay_jobs = false
+Delayed::Worker.backend    = :test
+

data/test/adapters/inline.rb

@@ -0,0 +1 @@
+ActiveJob::Base.queue_adapter = :inline

data/test/adapters/qu.rb

@@ -0,0 +1,3 @@
+require 'qu-immediate'
+
+ActiveJob::Base.queue_adapter = :qu

data/test/adapters/que.rb

@@ -0,0 +1,4 @@
+require 'support/que/inline'
+
+ActiveJob::Base.queue_adapter = :que
+Que.mode = :sync

data/test/adapters/queue_classic.rb

@@ -0,0 +1,2 @@
+require 'support/queue_classic/inline'
+ActiveJob::Base.queue_adapter = :queue_classic

data/test/adapters/resque.rb

@@ -0,0 +1,2 @@
+ActiveJob::Base.queue_adapter = :resque
+Resque.inline = true

data/test/adapters/sidekiq.rb

@@ -0,0 +1,2 @@
+require 'sidekiq/testing/inline'
+ActiveJob::Base.queue_adapter = :sidekiq

data/test/adapters/sneakers.rb

@@ -0,0 +1,2 @@
+require 'support/sneakers/inline'
+ActiveJob::Base.queue_adapter = :sneakers

data/test/adapters/sucker_punch.rb

@@ -0,0 +1,2 @@
+require 'sucker_punch/testing/inline'
+ActiveJob::Base.queue_adapter = :sucker_punch

data/test/cases/adapter_test.rb

@@ -0,0 +1,8 @@
+require 'helper'
+
+class AdapterTest < ActiveSupport::TestCase
+  test "should load #{ENV['AJADAPTER']} adapter" do
+    ActiveJob::Base.queue_adapter = ENV['AJADAPTER'].to_sym
+    assert_equal "active_job/queue_adapters/#{ENV['AJADAPTER']}_adapter".classify.constantize, ActiveJob::Base.queue_adapter
+  end
+end

data/test/cases/argument_serialization_test.rb

@@ -0,0 +1,84 @@
+require 'helper'
+require 'active_job/arguments'
+require 'models/person'
+require 'active_support/core_ext/hash/indifferent_access'
+
+class ArgumentSerializationTest < ActiveSupport::TestCase
+  setup do
+    @person = Person.find('5')
+  end
+
+  [ nil, 1, 1.0, 1_000_000_000_000_000_000_000,
+    'a', true, false,
+    [ 1, 'a' ],
+    { 'a' => 1 }
+  ].each do |arg|
+    test "serializes #{arg.class} verbatim" do
+      assert_arguments_unchanged arg
+    end
+  end
+
+  [ :a, Object.new, self, Person.find('5').to_gid ].each do |arg|
+    test "does not serialize #{arg.class}" do
+      assert_raises ActiveJob::SerializationError do
+        ActiveJob::Arguments.serialize [ arg ]
+      end
+
+      assert_raises ActiveJob::DeserializationError do
+        ActiveJob::Arguments.deserialize [ arg ]
+      end
+    end
+  end
+
+  test 'should convert records to Global IDs' do
+    assert_arguments_roundtrip [@person], ['_aj_globalid' => @person.to_gid.to_s]
+  end
+
+  test 'should dive deep into arrays and hashes' do
+    assert_arguments_roundtrip [3, [@person]], [3, ['_aj_globalid' => @person.to_gid.to_s]]
+    assert_arguments_roundtrip [{ 'a' => @person }], [{ 'a' => { '_aj_globalid' => @person.to_gid.to_s }}.with_indifferent_access]
+  end
+
+  test 'should stringify symbol hash keys' do
+    assert_equal [ 'a' => 1 ], ActiveJob::Arguments.serialize([ a: 1 ])
+  end
+
+  test 'should disallow non-string/symbol hash keys' do
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Arguments.serialize [ { 1 => 2 } ]
+    end
+
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Arguments.serialize [ { :a => [{ 2 => 3 }] } ]
+    end
+
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Arguments.serialize [ '_aj_globalid' => 1 ]
+    end
+
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Arguments.serialize [ :_aj_globalid => 1 ]
+    end
+  end
+
+  test 'should not allow non-primitive objects' do
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Arguments.serialize [Object.new]
+    end
+
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Arguments.serialize [1, [Object.new]]
+    end
+  end
+
+  private
+    def assert_arguments_unchanged(*args)
+      assert_arguments_roundtrip args, args
+    end
+
+    def assert_arguments_roundtrip(args, expected_serialized_args)
+      serialized = ActiveJob::Arguments.serialize(args)
+      assert_equal expected_serialized_args, serialized
+      assert_equal args, ActiveJob::Arguments.deserialize(serialized)
+    end
+end