activejob-retry 0.0.1 → 0.1.1

data/lib/active_job/retry/variable_options_validator.rb

@@ -0,0 +1,56 @@
+require 'active_job/retry/errors'
+
+module ActiveJob
+  module Retry
+    class VariableOptionsValidator
+      DELAY_MULTIPLIER_KEYS = [:min_delay_multiplier, :max_delay_multiplier].freeze
+
+      def initialize(options)
+        @options = options
+      end
+
+      def validate!
+        validate_banned_basic_option!(:limit)
+        validate_banned_basic_option!(:delay)
+        validate_delays!
+        validate_delay_multipliers!
+      end
+
+      private
+
+      attr_reader :options, :retry_limit
+
+      def validate_banned_basic_option!(key)
+        return unless options[key]
+
+        raise InvalidConfigurationError, "Cannot use #{key} with VariableBackoffStrategy"
+      end
+
+      def validate_delays!
+        return if options[:delays]
+
+        raise InvalidConfigurationError,
+              'You must define an array of delays between attempts'
+      end
+
+      def validate_delay_multipliers!
+        validate_delay_multipliers_supplied_together!
+
+        return unless options[:min_delay_multiplier] && options[:max_delay_multiplier]
+
+        return if options[:min_delay_multiplier] <= options[:max_delay_multiplier]
+
+        raise InvalidConfigurationError,
+              'min_delay_multiplier must be less than or equal to max_delay_multiplier'
+      end
+
+      def validate_delay_multipliers_supplied_together!
+        supplied = DELAY_MULTIPLIER_KEYS.map { |key| options.key?(key) }
+        return if supplied.none? || supplied.all?
+
+        raise InvalidConfigurationError,
+              'If one of min/max_delay_multiplier is supplied, both are required'
+      end
+    end
+  end
+end

data/lib/active_job/retry/version.rb

@@ -1,5 +1,5 @@
 module ActiveJob
   module Retry
-    VERSION = "0.0.1"
+    VERSION = '0.1.1'
   end
 end

data/spec/retry/constant_backoff_strategy_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+RSpec.describe ActiveJob::Retry::ConstantBackoffStrategy do
+  let(:strategy) { described_class.new(options) }
+
+  describe '#should_retry?' do
+    subject { strategy.should_retry?(attempt, exception) }
+    let(:attempt) { 1 }
+    let(:exception) { RuntimeError.new }
+
+    context 'when the limit is infinite' do
+      let(:options) { { limit: nil, unlimited_retries: true } }
+
+      context '1st attempt' do
+        let(:attempt) { 1 }
+        it { is_expected.to be(true) }
+      end
+
+      context '99999th attempt' do
+        let(:attempt) { 99_999 }
+        it { is_expected.to be(true) }
+      end
+    end
+
+    context 'when the limit is 0' do
+      let(:options) { { limit: 0 } }
+
+      context '1st attempt' do
+        let(:attempt) { 1 }
+        it { is_expected.to be(false) }
+      end
+
+      context '99999th attempt' do
+        let(:attempt) { 99_999 }
+        it { is_expected.to be(false) }
+      end
+    end
+
+    context 'when the limit is 5' do
+      let(:options) { { limit: 5 } }
+
+      context '1st attempt' do
+        let(:attempt) { 1 }
+        it { is_expected.to be(true) }
+      end
+
+      context '4th attempt' do
+        let(:attempt) { 4 }
+        it { is_expected.to be(true) }
+      end
+
+      context '5th attempt' do
+        let(:attempt) { 5 }
+        it { is_expected.to be(false) }
+      end
+    end
+
+    context 'defaults (retry everything)' do
+      let(:options) { { limit: 10 } }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be(true) }
+      end
+    end
+
+    context 'with whitelist' do
+      let(:options) { { limit: 10, retry_exceptions: [RuntimeError] } }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be(false) }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be(true) }
+      end
+    end
+
+    context 'with blacklist' do
+      let(:options) { { limit: 10, fatal_exceptions: [RuntimeError] } }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be(false) }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be(false) }
+      end
+    end
+  end
+end

data/spec/retry/constant_options_validator_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe ActiveJob::Retry::ConstantOptionsValidator do
+  let(:validator) { described_class.new(options) }
+  subject(:validate!) { -> { validator.validate! } }
+
+  context 'valid options' do
+    context 'unlimited retries' do
+      let(:options) { { limit: nil, unlimited_retries: true } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'no retries' do
+      let(:options) { { limit: 0 } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'some retries' do
+      let(:options) { { limit: 3 } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'zero delay' do
+      let(:options) { { delay: 0 } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'fatal exceptions' do
+      let(:options) { { fatal_exceptions: [RuntimeError] } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'retry exceptions' do
+      let(:options) { { retry_exceptions: [StandardError, NoMethodError] } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'multiple options' do
+      let(:options) { { limit: 3, delay: 10, retry_exceptions: [RuntimeError] } }
+
+      it { is_expected.to_not raise_error }
+    end
+  end
+
+  context 'invalid options' do
+    context 'bad limit' do
+      let(:options) { { limit: -1 } }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    context 'accidental infinite limit' do
+      let(:options) { { limit: nil } }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    context 'accidental finite limit' do
+      let(:options) { { unlimited_retries: true } }
+      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
+
+    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) }
+    end
+  end
+end

data/spec/retry/variable_backoff_strategy_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+RSpec.describe ActiveJob::Retry::VariableBackoffStrategy do
+  let(:backoff_strategy) { described_class.new(options) }
+
+  describe '#should_retry?' do
+    subject { backoff_strategy.should_retry?(attempt, exception) }
+    let(:attempt) { 1 }
+    let(:exception) { RuntimeError.new }
+
+    context 'when the strategy is empty' do
+      let(:options) { { delays: [] } }
+
+      context '1st attempt' do
+        let(:attempt) { 1 }
+        it { is_expected.to be(false) }
+      end
+
+      context '99999th attempt' do
+        let(:attempt) { 99_999 }
+        it { is_expected.to be(false) }
+      end
+    end
+
+    context 'when the strategy has 4 delays' do
+      let(:options) { { delays: [0, 3, 5, 10] } }
+
+      context '1st attempt' do
+        let(:attempt) { 1 }
+        it { is_expected.to be(true) }
+      end
+
+      context '4th attempt' do
+        let(:attempt) { 4 }
+        it { is_expected.to be(true) }
+      end
+
+      context '5th attempt' do
+        let(:attempt) { 5 }
+        it { is_expected.to be(false) }
+      end
+    end
+
+    context 'defaults (retry everything)' do
+      let(:options) { { delays: [0, 3, 5, 10, 60] } }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be(true) }
+      end
+    end
+
+    context 'with whitelist' do
+      let(:options) { { delays: [10], retry_exceptions: [RuntimeError] } }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be(false) }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be(true) }
+      end
+    end
+
+    context 'with blacklist' do
+      let(:options) { { delays: [10], fatal_exceptions: [RuntimeError] } }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be(true) }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be(false) }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be(false) }
+      end
+    end
+  end
+
+  describe '#retry_delay' do
+    subject { backoff_strategy.retry_delay(attempt, exception) }
+    let(:attempt) { 1 }
+    let(:exception) { RuntimeError.new }
+
+    context 'when the strategy has 4 delays' do
+      let(:options) { { delays: [0, 3, 5, 10] } }
+
+      context '1st attempt' do
+        let(:attempt) { 1 }
+        it { is_expected.to eq(0) }
+      end
+
+      context '4th attempt' do
+        let(:attempt) { 4 }
+        it { is_expected.to eq(10) }
+      end
+    end
+  end
+end

data/spec/retry/variable_options_validator_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+RSpec.describe ActiveJob::Retry::VariableOptionsValidator do
+  let(:validator) { described_class.new(options) }
+  subject(:validate!) { -> { validator.validate! } }
+
+  context 'valid options' do
+    context 'empty delays' do
+      let(:options) { { delays: [] } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'with delays' do
+      let(:options) { { delays: [0, 3, 6, 10_000] } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'min and max delay multipliers' do
+      let(:options) do
+        { delays: [0, 10, 60], min_delay_multiplier: 0.8, max_delay_multiplier: 1.2 }
+      end
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'fatal exceptions' do
+      let(:options) { { delays: [0, 10, 60], fatal_exceptions: [RuntimeError] } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'retry exceptions' do
+      let(:options) { { delays: [], retry_exceptions: [StandardError, NoMethodError] } }
+      it { is_expected.to_not raise_error }
+    end
+
+    context 'multiple options' do
+      let(:options) { { delays: [0, 10, 60], retry_exceptions: [RuntimeError] } }
+
+      it { is_expected.to_not raise_error }
+    end
+  end
+
+  context 'invalid options' do
+    context 'without delays' do
+      let(:options) { {} }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    context 'with limit' do
+      let(:options) { { limit: 5 } }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    context 'with delay' do
+      let(:options) { { delay: 5 } }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    context 'min delay multiplier only' do
+      let(:options) { { min_delay_multiplier: 0.8 } }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    context 'max delay multiplier only' do
+      let(:options) { { max_delay_multiplier: 0.8 } }
+      it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+    end
+
+    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) }
+    end
+  end
+end