take2 0.0.3 → 1.0.0

data/lib/take2/configuration.rb

@@ -1,23 +1,26 @@
+# frozen_string_literal: true
+
+require 'take2/backoff'
+
 module Take2
   class Configuration
-    CONFIG_ATTRS = [:retries, :retriable, :retry_proc, :retry_condition_proc, :time_to_sleep].freeze
+    CONFIG_ATTRS = [:retries,
+                    :retriable,
+                    :retry_proc,
+                    :retry_condition_proc,
+                    :backoff_intervals].freeze
+
     attr_accessor(*CONFIG_ATTRS)
 
     def initialize(options = {})
       # Defaults
       @retries = 3
-      @retriable = [
-        Net::HTTPServerError,
-        Net::HTTPServerException,
-        Net::HTTPRetriableError,        
-        Errno::ECONNRESET,
-        IOError,
-       ].freeze
+      @retriable = []
       @retry_proc = proc {}
       @retry_condition_proc = proc { false }
-      @time_to_sleep = 3
-      # Overwriting the defaults
-      validate_options(options, &setter)
+      @backoff_intervals = Backoff.new(:constant, 3).intervals
+
+      merge_options!(options)
     end
 
     def to_hash
@@ -27,29 +30,31 @@ module Take2
     end
 
     def [](value)
-      self.public_send(value)
+      public_send(value)
     end
 
-    def validate_options(options, &setter)
+    def merge_options!(options = {})
+      validate!(options).each do |key, value|
+        public_send("#{key}=", value)
+      end
+      self
+    end
+
+    def validate!(options)
       options.each do |k, v|
-        raise ArgumentError, "#{k} is not a valid configuration"  unless CONFIG_ATTRS.include?(k)
+        raise ArgumentError, "#{k} is not a valid configuration" unless CONFIG_ATTRS.include?(k)
         case k
-          when :retries
-            raise ArgumentError, "#{k} must be positive integer" unless v.is_a?(Integer) && v.positive?
-          when :time_to_sleep  
-            raise ArgumentError, "#{k} must be positive number" unless (v.is_a?(Integer) || v.is_a?(Float)) && v >= 0
-          when :retriable
-            raise ArgumentError, "#{k} must be array of retriable errors" unless v.is_a?(Array)
-          when :retry_proc, :retry_condition_proc
-            raise ArgumentError, "#{k} must be Proc" unless v.is_a?(Proc)
+        when :retries
+          raise ArgumentError, "#{k} must be positive integer" unless v.is_a?(Integer) && v.positive?
+        when :retriable
+          raise ArgumentError, "#{k} must be array of retriable errors" unless v.is_a?(Array)
+        when :backoff_intervals
+          raise ArgumentError, "#{k} must be array of retriable errors" unless v.is_a?(Array)
+          raise ArgumentError, "#{k} size must be greater or equal to number of retries" unless v.size >= retries
+        when :retry_proc, :retry_condition_proc
+          raise ArgumentError, "#{k} must be Proc" unless v.is_a?(Proc)
         end
-        setter.call(k, v) if block_given?
-      end  
-    end
-
-    def setter
-      proc { |key, value| instance_variable_set(:"@#{key}", value) }
+      end
     end
-
   end
-end
+end

data/lib/take2/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Take2
-  VERSION = "0.0.3"
-end
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rspec'
 require 'take2'
-require 'pry'
+require 'pry'

data/spec/take2/configuration_spec.rb

@@ -1,125 +1,96 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-RSpec.describe Take2::Configuration do
+require 'spec_helper'
 
+RSpec.describe(Take2::Configuration) do
   describe 'default configurations' do
-
     let(:default) { described_class.new }
 
     it 'has correct default value for retries' do
-      expect(default.retries).to eql 3
+      expect(default.retries).to(eql(3))
     end
 
     it 'has correct default retriable errors array' do
-      expect(default.retriable).to eql [
-        Net::HTTPServerError,
-        Net::HTTPServerException,
-        Net::HTTPRetriableError,        
-        Errno::ECONNRESET,
-        IOError,
-       ].freeze
+      expect(default.retriable).to(eql([]))
     end
 
     it 'has default proc for retry_proc' do
       p = proc {}
-      expect(default.retry_proc.call).to eql p.call
+      expect(default.retry_proc.call).to(eql(p.call))
     end
 
     it 'has default proc for retry_condition_proc' do
-      p = proc {false}
-      expect(default.retry_condition_proc.call).to eql p.call
+      p = proc { false }
+      expect(default.retry_condition_proc.call).to(eql(p.call))
     end
 
-    it 'has correct default value for time_to_sleep' do
-      expect(default.time_to_sleep).to eql 3
+    it 'has correct default value for backoff_intervals' do
+      expect(default.backoff_intervals).to eql Array.new(10, 3)
     end
-
   end
 
   describe 'overwriting the default configurations' do
-
     context 'with valid hash' do
-
-      let!(:new_configs_hash) { 
+      let!(:new_configs_hash) do
         {
           retries: 2,
           retriable: [Net::HTTPRetriableError],
           retry_condition_proc: proc { true },
-          retry_proc: proc { 2*2 },
-          time_to_sleep: 0
+          retry_proc: proc { 2 * 2 },
+          backoff_intervals: [1, 2, 3, 4, 5]
         }
-      }
+      end
 
       let!(:new_configuration) { described_class.new(new_configs_hash).to_hash }
 
-      [:retries, :retriable, :retry_proc, :retry_condition_proc, :time_to_sleep].each do |key|
+      [:retries, :retriable, :retry_proc, :retry_condition_proc, :backoff_intervals].each do |key|
         it "sets the #{key} key" do
           if new_configs_hash[key].respond_to?(:call)
-            expect(new_configuration[key].call).to eql new_configs_hash[key].call
-          else  
-            expect(new_configuration[key]).to eql new_configs_hash[key]
+            expect(new_configuration[key].call).to(eql(new_configs_hash[key].call))
+          else
+            expect(new_configuration[key]).to(eql(new_configs_hash[key]))
           end
         end
       end
-
     end
 
     context 'with invalid hash' do
-
       context 'when retries set to invalid value' do
-
-        it 'raises ArgumentError' do
-
-          expect { described_class.new(retries: -1) }.to raise_error ArgumentError
-          expect { described_class.new(retries: 0) }.to raise_error ArgumentError
-
-        end
-
-      end
-
-      context 'when time_to_sleep set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(time_to_sleep: -1) }.to raise_error ArgumentError
-          
+          expect { described_class.new(retries: -1) }.to(raise_error(ArgumentError))
+          expect { described_class.new(retries: 0) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when retriable set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(retriable: StandardError) }.to raise_error ArgumentError
-          
+          expect { described_class.new(retriable: StandardError) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when retry_proc set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(retry_proc: {}) }.to raise_error ArgumentError
-          
+          expect { described_class.new(retry_proc: {}) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when retry_condition_proc set to invalid value' do
-
         it 'raises ArgumentError' do
+          expect { described_class.new(retry_condition_proc: {}) }.to(raise_error(ArgumentError))
+        end
+      end
 
-          expect { described_class.new(retry_condition_proc: {}) }.to raise_error ArgumentError
-          
+      context 'when backoff_intervals has incorrect type' do
+        it 'raises ArgumentError' do
+          expect { described_class.new(backoff_intervals: 1) }.to(raise_error(ArgumentError))
         end
+      end
 
+      context 'when backoff_intervals size smaller then number of retries' do
+        it 'raises ArgumentError' do
+          expect { described_class.new(backoff_intervals: [1]) }.to(raise_error(ArgumentError))
+        end
       end
-      
     end
-
   end
-
-
-end
+end

data/spec/take2_spec.rb

@@ -1,162 +1,127 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-RSpec.describe Take2 do
+require 'spec_helper'
 
+RSpec.describe(Take2) do
   let!(:config) do
     Take2.configure do |c|
       c.retries               = 1
-      c.retriable             = [Net::HTTPServerError, Net::HTTPRetriableError].freeze
-      c.retry_condition_proc  = proc {false}
+      c.retriable             = [Errno::ECONNRESET, Net::HTTPRetriableError].freeze
+      c.retry_condition_proc  = proc { false }
       c.retry_proc            = proc {}
-      c.time_to_sleep         = 0.5
+      c.backoff_intervals     = Take2::Backoff.new(:linear, 1).intervals
     end
   end
   let(:klass)   { Class.new { include Take2 } }
   let(:object)  { klass.new }
 
   describe 'default values' do
-
     subject { klass.retriable_configuration }
 
     it 'has a default value for :retries' do
-      expect(subject[:retries]).to eql described_class.configuration[:retries]
+      expect(subject[:retries]).to(eql(described_class.configuration[:retries]))
     end
 
     it 'has a default value for :retriable' do
-      expect(subject[:retriable]).to eql described_class.configuration[:retriable]
+      expect(subject[:retriable]).to(eql(described_class.configuration[:retriable]))
     end
 
     it 'has a default value for :retry_condition_proc' do
-      expect(subject[:retry_condition_proc].call).to eql described_class.configuration[:retry_condition_proc].call
+      expect(subject[:retry_condition_proc].call).to(eql(described_class.configuration[:retry_condition_proc].call))
     end
 
     it 'has a default value for :retry_proc' do
-      expect(subject[:retry_proc].call).to eql described_class.configuration[:retry_proc].call
+      expect(subject[:retry_proc].call).to(eql(described_class.configuration[:retry_proc].call))
     end
 
-    it 'has a default value for :time_to_sleep' do
-      expect(subject[:time_to_sleep]).to eql described_class.configuration[:time_to_sleep]
+    it 'has a default value for :backoff_intervals' do
+      expect(subject[:backoff_intervals]).to eql((1..10).to_a)
     end
-
   end
 
   describe 'included class helpers' do
-
     subject { klass.retriable_configuration }
 
     describe '.number_of_retries' do
-
       context 'with valid argument' do
-
         it 'sets the :retries attribute' do
-          klass.number_of_retries 1
-          expect(subject[:retries]).to eql 1
+          klass.number_of_retries(1)
+          expect(subject[:retries]).to(eql(1))
         end
-
       end
 
       context 'with invalid argument' do
-
         it 'raises ArgumentError' do
-          expect { klass.number_of_retries 0 }.to raise_error ArgumentError
+          expect { klass.number_of_retries(0) }.to(raise_error(ArgumentError))
         end
-
       end
-
     end
 
     describe '.retriable_errors' do
-
       context 'with valid argument' do
-
         it 'sets the :retriable_errors attribute' do
           retriables = IOError
-          klass.retriable_errors retriables
-          expect(subject[:retriable]).to eql [retriables]
+          klass.retriable_errors(retriables)
+          expect(subject[:retriable]).to(eql([retriables]))
         end
-
       end
 
       context 'with invalid argument' do
-
         it 'raises ArgumentError' do
           class Klass; end
-          expect { klass.retriable_errors Klass }.to raise_error ArgumentError
+          expect { klass.retriable_errors(Klass) }.to(raise_error(ArgumentError))
         end
-
       end
-
     end
 
     describe '.retriable_condition' do
-
       context 'with valid argument' do
-
         it 'sets the :retriable_condition attribute' do
           retriable_proc = proc { 'Ho-Ho-Ho' }
-          klass.retriable_condition retriable_proc
-          expect(subject[:retry_condition_proc].call).to eql retriable_proc.call
+          klass.retriable_condition(retriable_proc)
+          expect(subject[:retry_condition_proc].call).to(eql(retriable_proc.call))
         end
-
       end
 
       context 'with invalid argument' do
-
-         it 'raises ArgumentError' do
-          expect { klass.retriable_condition Class.new }.to raise_error ArgumentError
-         end
-
+        it 'raises ArgumentError' do
+          expect { klass.retriable_condition(Class.new) }.to(raise_error(ArgumentError))
+        end
       end
-
     end
 
     describe '.on_retry' do
-
       context 'with valid argument' do
-
         it 'sets the :on_retry attribute' do
           retry_proc = proc { |el| el }
-          klass.on_retry retry_proc
-          expect(subject[:retry_proc].call).to eql retry_proc.call
+          klass.on_retry(retry_proc)
+          expect(subject[:retry_proc].call).to(eql(retry_proc.call))
         end
-
-      end  
+      end
 
       context 'with invalid argument' do
-
         it 'raises ArgumentError' do
-          expect { klass.on_retry Class.new }.to raise_error ArgumentError
+          expect { klass.on_retry(Class.new) }.to(raise_error(ArgumentError))
         end
-
       end
-
     end
 
-    describe '.sleep_before_retry' do
-
-      context 'with valid argument' do
-
-        it 'sets the :sleep_before_retry attribute' do
-          klass.sleep_before_retry 3.5
-          expect(subject[:time_to_sleep]).to eql 3.5
+    describe '.backoff_setup' do
+      context 'with valid arguments' do
+        it 'sets the backoff_intervals' do
+          klass.backoff_strategy(type: :fibonacci, start: 3)
+          expect(subject[:backoff_intervals]).to eql([3, 5, 8, 13, 21, 34, 55, 89, 144, 233])
         end
-
       end
-      
-      context 'with invalid argument' do
-
+      context 'with invalid backoff type' do
         it 'raises ArgumentError' do
-          expect { klass.sleep_before_retry -1 }.to raise_error ArgumentError
+          expect { klass.backoff_strategy(type: :not_real, start: 3) }.to(raise_error(ArgumentError))
         end
-
       end
-
     end
-
   end
 
   describe '.call_api_with_retry' do
-
     def increment_retry_counter
       @tries += 1
     end
@@ -166,115 +131,144 @@ RSpec.describe Take2 do
       raise error
     end
 
-    context 'when raised with non retriable error' do
-
-      let(:error) { StandardError.new 'Release the Kraken!!' }
-
+    describe 'class method' do
+      let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
       before(:each) { @tries = 0 }
 
-      it 're raises the original error' do
-        expect do
-          object.call_api_with_retry { wrath_the_gods_with error }
-        end.to raise_error error.class
+      it 'responds to the method' do
+        expect(klass).to respond_to(:call_api_with_retry)
+        expect(klass).to respond_to(:with_retry)
+        expect(klass.method(:with_retry).original_name).to eq(klass.method(:call_api_with_retry).original_name)
+        expect(klass.method(:with_retry).source_location).to eq(klass.method(:call_api_with_retry).source_location)
       end
 
-      it 'is not retried' do
+      it 'retries correct number of times' do
         expect do
-          object.call_api_with_retry { wrath_the_gods_with error } rescue nil
-        end.to change{@tries}.from(0).to(1)
+          klass.call_api_with_retry { wrath_the_gods_with retriable_error }
+        end.to(change { @tries }.from(0).to(klass.retriable_configuration[:retries] + 1))
+      rescue
+        nil
       end
-
-      # it 'logs the error' do
-      #   expect(object).to receive(:log_error).with(error)
-      #   object.call_api_with_retry { wrath_the_gods_with error } rescue nil
-      # end
-
     end
 
-    context 'when raised with retriable error' do
+    describe 'instance method' do
+      it 'responds to the method' do
+        expect(object).to respond_to(:call_api_with_retry)
+        expect(object).to respond_to(:with_retry)
+        expect(object.method(:with_retry).original_name).to eq(object.method(:call_api_with_retry).original_name)
+        expect(object.method(:with_retry).source_location).to eq(object.method(:call_api_with_retry).source_location)
+      end
 
-      let(:retriable_error) {  Net::HTTPRetriableError.new 'Release the Kraken...many times!!', nil }
+      context 'when raised with non retriable error' do
+        let(:error) { StandardError.new('Release the Kraken!!') }
 
-      before(:each) { @tries = 0 }
+        before(:each) { @tries = 0 }
 
-      it 'retries correct number of times' do
-        expect do
-          object.call_api_with_retry { wrath_the_gods_with retriable_error } rescue nil
-        end.to change {@tries}.from(0).to(klass.retriable_configuration[:retries] + 1)
-      end
+        it 're raises the original error' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with error }
+          end.to(raise_error(error.class))
+        end
 
-      it 'calls the retry proc' do
-        expect(klass.retriable_configuration[:retry_proc]).to receive(:call).exactly(klass.retriable_configuration[:retries])
-        object.call_api_with_retry { wrath_the_gods_with retriable_error } rescue nil
+        it 'is not retried' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with error }
+          end.to(change { @tries }.from(0).to(1))
+        rescue
+          nil
+        end
       end
 
-      it 'calls the retry_condition proc' do
-        expect(klass.retriable_configuration[:retry_condition_proc]).to receive(:call).exactly(klass.retriable_configuration[:retries])
-        object.call_api_with_retry { wrath_the_gods_with retriable_error } rescue nil
-      end
+      context 'when raised with retriable error' do
+        let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
 
-      it 'sleeps the correct amount of time' do
-        allow_any_instance_of(Object).to receive(:sleep).with(klass.retriable_configuration[:time_to_sleep])
-        object.call_api_with_retry { wrath_the_gods_with retriable_error } rescue nil
-      end
+        before(:each) { @tries = 0 }
 
-      # it 'logs the error' do
-      #   expect(object).to receive(:log_error).with(retriable_error)
-      #   object.call_api_with_retry { wrath_the_gods_with retriable_error } rescue nil
-      # end
+        it 'retries correct number of times' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          end.to(change { @tries }.from(0).to(klass.retriable_configuration[:retries] + 1))
+        rescue
+          nil
+        end
 
-      it 're raises the original error' do
-        expect do
-          object.call_api_with_retry { wrath_the_gods_with retriable_error }
-        end.to raise_error retriable_error.class
-      end
+        it 'calls the retry proc' do
+          expect(klass.retriable_configuration[:retry_proc])
+            .to(receive(:call)
+            .exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-    end
+        it 'calls the retry_condition proc' do
+          expect(klass.retriable_configuration[:retry_condition_proc])
+            .to(receive(:call)
+            .exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-    context 'with custom options' do
+        it 're raises the original error' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          end.to(raise_error(retriable_error.class))
+        end
+      end
 
-      let(:retriable_error)     { Net::HTTPRetriableError.new 'Release the Kraken...many times!!', nil }
-      let(:new_retriable_error) { IOError.new 'You shall not PASS!' }
+      context 'with custom options' do
+        let(:retriable_error)     { Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
+        let(:new_retriable_error) { IOError.new('You shall not PASS!') }
 
-      before(:each) { @tries = 0 }
-        
-      it 'overwrites the :retries' do
-        expect do
-          object.call_api_with_retry(retries: 3) { wrath_the_gods_with retriable_error } rescue nil
-        end.to change { @tries }.from(0).to(4)
-      end
+        before(:each) { @tries = 0 }
 
-      it 'overwrites the :retry_proc' do
-        new_proc = proc { 1**1 }
-        expect(new_proc).to receive(:call).exactly(klass.retriable_configuration[:retries])
-        object.call_api_with_retry(retry_proc: new_proc) { wrath_the_gods_with retriable_error } rescue nil          
-      end
+        it 'overwrites the :retries' do
+          expect do
+            object.call_api_with_retry(retries: 3) { wrath_the_gods_with retriable_error }
+          end.to(change { @tries }.from(0).to(4))
+        rescue
+          nil
+        end
 
-      it 'overwrites the :retry_condition_proc' do
-        new_proc = proc { true }
-        expect(new_proc).to receive(:call).exactly(klass.retriable_configuration[:retries])
-        object.call_api_with_retry(retry_condition_proc: new_proc) { wrath_the_gods_with retriable_error } rescue nil          
-      end
+        it 'overwrites the :retry_proc' do
+          new_proc = proc { 1**1 }
+          expect(new_proc).to(receive(:call).exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry(retry_proc: new_proc) { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-      it 'overwrites the :time_to_sleep' do
-        allow_any_instance_of(Object).to receive(:sleep).with(1.66)
-        object.call_api_with_retry(time_to_sleep: 1.66) { wrath_the_gods_with retriable_error } rescue nil
-      end
+        it 'overwrites the :retry_condition_proc' do
+          new_proc = proc { true }
+          expect(new_proc).to(receive(:call).exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry(retry_condition_proc: new_proc) { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-      it 'overwrites the :retriable' do
-        expect do                
-          object.call_api_with_retry(retriable: [new_retriable_error]) { wrath_the_gods_with retriable_error } rescue nil
-        end.to change { @tries }.from(0).to(1)
-      end
+        it 'overwrites the :retriable' do
+          expect do
+            object.call_api_with_retry(retriable: [new_retriable_error]) { wrath_the_gods_with retriable_error }
+          end.to(change { @tries }.from(0).to(1))
+        rescue
+          nil
+        end
 
-      it 'raises ArgumentError if there are invalid keys' do
-        expect do                
-          object.call_api_with_retry(invalid_key: :nope) { wrath_the_gods_with retriable_error }
-        end.to raise_error ArgumentError
+        it 'raises ArgumentError if there are invalid keys' do
+          expect do
+            object.call_api_with_retry(invalid_key: :nope) { wrath_the_gods_with retriable_error }
+          end.to(raise_error(ArgumentError))
+        end
       end
-
     end
-
   end
-
-end
+end