take2 0.0.4 → 0.0.5

data/spec/take2_spec.rb

@@ -1,162 +1,147 @@
-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::HTTPServerException, Net::HTTPRetriableError].freeze
-      c.retry_condition_proc  = proc {false}
+      c.retry_condition_proc  = proc { false }
       c.retry_proc            = proc {}
-      c.time_to_sleep         = 0.5
+      c.time_to_sleep         = 0
+      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]
+      expect(subject[:time_to_sleep]).to(eql(described_class.configuration[:time_to_sleep]))
     end
 
+    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
+          klass.sleep_before_retry(3.5)
+          expect(subject[:time_to_sleep]).to(eql(3.5))
         end
-
       end
-      
-      context 'with invalid argument' do
 
+      context 'with invalid argument' do
         it 'raises ArgumentError' do
-          expect { klass.sleep_before_retry -1 }.to raise_error ArgumentError
+          expect { klass.sleep_before_retry(-1) }.to(raise_error(ArgumentError))
         end
-
       end
-
     end
 
+    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 backoff type' do
+        it 'raises ArgumentError' do
+          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
@@ -167,114 +152,132 @@ RSpec.describe Take2 do
     end
 
     context 'when raised with non retriable error' do
-
-      let(:error) { StandardError.new 'Release the Kraken!!' }
+      let(:error) { StandardError.new('Release the Kraken!!') }
 
       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
+        end.to(raise_error(error.class))
       end
 
       it 'is not retried' do
         expect do
-          object.call_api_with_retry { wrath_the_gods_with error } rescue nil
-        end.to change{@tries}.from(0).to(1)
+          object.call_api_with_retry { wrath_the_gods_with error }
+        end.to(change { @tries }.from(0).to(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
-
-      let(:retriable_error) {  Net::HTTPRetriableError.new 'Release the Kraken...many times!!', nil }
+      let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
 
       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)
+          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 '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
+        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
 
       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
-
-      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
+        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
 
-      # 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
+      # it 'sleeps the correct amount of time' do
+      #   allow_any_instance_of(Object).to(receive(:sleep).with(klass.retriable_configuration[:time_to_sleep]))
+      #   begin
+      #     object.call_api_with_retry { wrath_the_gods_with retriable_error }
+      #   rescue
+      #     nil
+      #   end
       # 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.to(raise_error(retriable_error.class))
       end
-
     end
 
     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!' }
+      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)
+          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_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          
+        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 :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          
+        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 :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 :time_to_sleep' do
+      #   allow_any_instance_of(Object).to(receive(:sleep).with(1.66))
+      #   begin
+      #     object.call_api_with_retry(time_to_sleep: 1.66) { 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)
+        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                
+        expect do
           object.call_api_with_retry(invalid_key: :nope) { wrath_the_gods_with retriable_error }
-        end.to raise_error ArgumentError
+        end.to(raise_error(ArgumentError))
       end
-
     end
-
   end
-
-end
+end

data/take2.gemspec

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require File.expand_path("../lib/take2/version", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "take2"
   s.version     = Take2::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.licenses    = ['MIT']
+  s.licenses    = %w(MIT)
   s.authors     = ["Anton Magids"]
   s.email       = ["evnomadx@gmail.com"]
   s.homepage    = "https://github.com/restaurant-cheetah/take2"
@@ -12,10 +14,10 @@ Gem::Specification.new do |s|
   s.description = "Retry API calls, methods or blocks of code. Define take2 retry behavior or use defaults and you good to go."
   s.post_install_message = "Getting Take2 is dead easy!"
 
-  all_files = `git ls-files`.split("\n")
-  test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  
+  all_files = %x(git ls-files).split("\n")
+  test_files = %x(git ls-files -- {test,spec,features}/*).split("\n")
+
   s.files         = all_files - test_files
   s.test_files    = test_files
-  s.require_paths = ['lib']
-end
+  s.require_paths = %w(lib)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: take2
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Anton Magids
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-22 00:00:00.000000000 Z
+date: 2019-02-09 00:00:00.000000000 Z
 dependencies: []
 description: Retry API calls, methods or blocks of code. Define take2 retry behavior
   or use defaults and you good to go.
@@ -22,6 +22,8 @@ files:
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".gitignore"
+- ".hound.yml"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -29,6 +31,7 @@ files:
 - README.md
 - Rakefile
 - lib/take2.rb
+- lib/take2/backoff.rb
 - lib/take2/configuration.rb
 - lib/take2/version.rb
 - spec/spec_helper.rb