retryable 2.0.4 → 3.0.5

data/retryable.gemspec

@@ -1,20 +1,31 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/retryable/version', __FILE__)
+# rubocop:disable Style/ExpandPathArguments
+lib = File.expand_path('../lib', __FILE__)
+# rubocop:enable Style/ExpandPathArguments
 
-Gem::Specification.new do |gem|
-  gem.add_development_dependency 'bundler', '~> 1.0'
-  gem.authors = ["Nikita Fedyashev", "Carlo Zottmann", "Chu Yeow"]
-  gem.description = %q{Retryable#retryable, allow for retrying of code blocks.}
-  gem.email = %q{nfedyashev@gmail.com}
-  gem.files = %w(CHANGELOG.md LICENSE.md README.md Rakefile retryable.gemspec)
-  gem.files += Dir.glob("lib/**/*.rb")
-  gem.files += Dir.glob("spec/**/*")
-  gem.homepage = %q{http://github.com/nfedyashev/retryable}
-  gem.name = 'retryable'
-  gem.license = 'MIT'
-  gem.require_paths = ["lib"]
-  gem.required_rubygems_version = '>= 1.3.6'
-  gem.summary = gem.description
-  gem.test_files = Dir.glob("spec/**/*")
-  gem.version = Retryable::Version
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'retryable/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'retryable'
+  spec.version = Retryable::Version
+  spec.authors = ['Nikita Fedyashev', 'Carlo Zottmann', 'Chu Yeow']
+  spec.email   = ['nfedyashev@gmail.com']
+
+  spec.summary     = 'Retrying code blocks in Ruby'
+  spec.description = spec.summary
+  spec.homepage    = 'http://github.com/nfedyashev/retryable'
+  spec.metadata = {
+    'changelog_uri' => 'https://github.com/nfedyashev/retryable/blob/master/CHANGELOG.md',
+    'source_code_uri' => 'https://github.com/nfedyashev/retryable/tree/master'
+  }
+  spec.licenses    = ['MIT']
+
+  spec.require_paths = ['lib']
+  spec.files         = Dir['{config,lib,spec}/**/*', '*.md', '*.gemspec', 'Gemfile', 'Rakefile']
+  spec.test_files    = spec.files.grep(%r{^spec/})
+
+  spec.required_ruby_version     = Gem::Requirement.new('>= 1.9.3')
+  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
+
+  spec.add_development_dependency 'bundler'
 end

data/spec/retryable/configuration_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe Retryable do
+  it 'is enabled by default' do
+    expect(described_class).to be_enabled
+  end
+
+  it 'could be disabled' do
+    described_class.disable
+    expect(described_class).not_to be_enabled
+  end
+
+  context 'when disabled' do
+    before do
+      described_class.disable
+    end
+
+    it 'could be re-enabled' do
+      described_class.enable
+      expect(described_class).to be_enabled
+    end
+  end
+
+  context 'when configured locally' do
+    it 'does not affect the original global config' do
+      new_sleep = 2
+      original_sleep = described_class.configuration.send(:sleep)
+
+      expect(original_sleep).not_to eq(new_sleep)
+
+      counter(tries: 2, sleep: new_sleep) do |tries, ex|
+        raise StandardError if tries < 1
+      end
+
+      actual = described_class.configuration.send(:sleep)
+      expect(actual).to eq(original_sleep)
+    end
+  end
+
+  context 'when configured globally with custom sleep parameter' do
+    it 'passes retry count and exception on retry' do
+      expect(Kernel).to receive(:sleep).once.with(3)
+
+      described_class.configure do |config|
+        config.sleep = 3
+      end
+
+      counter(tries: 2) do |tries, ex|
+        expect(ex.class).to eq(StandardError) if tries > 0
+        raise StandardError if tries < 1
+      end
+      expect(counter.count).to eq(2)
+    end
+  end
+end

data/spec/retryable/version_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+RSpec.describe Retryable::Version do
+  before do
+    allow(described_class).to receive(:major).and_return(2)
+    allow(described_class).to receive(:minor).and_return(0)
+    allow(described_class).to receive(:patch).and_return(4)
+  end
+
+  describe '.to_h' do
+    it 'returns a hash with the right values' do
+      expect(described_class.to_h).to be_a Hash
+      expect(described_class.to_h[:major]).to eq(2)
+      expect(described_class.to_h[:minor]).to eq(0)
+      expect(described_class.to_h[:patch]).to eq(4)
+    end
+  end
+
+  describe '.to_a' do
+    it 'returns an array with the right values' do
+      expect(described_class.to_a).to be_an Array
+      expect(described_class.to_a).to eq([2, 0, 4])
+    end
+  end
+
+  describe '.to_s' do
+    it 'returns a string with the right value' do
+      expect(described_class.to_s).to be_a String
+      expect(described_class.to_s).to eq('2.0.4')
+    end
+  end
+end

data/spec/retryable_logging_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'logger'
+
+RSpec.describe Retryable do
+  describe '.retryable' do
+    before do
+      described_class.enable
+      expect(Kernel).to receive(:sleep)
+    end
+
+    let(:retryable) do
+      -> { Retryable.retryable(tries: 2) { |tries| raise StandardError, "because foo" if tries < 1 } }
+    end
+
+    context 'given default configuration' do
+      it 'does not output anything' do
+        expect { retryable.call }.not_to output.to_stdout_from_any_process
+      end
+    end
+
+    context 'given custom STDOUT logger config option' do
+      it 'does not output anything' do
+        described_class.configure do |config|
+          config.log_method = lambda do |retries, exception|
+             Logger.new(STDOUT).debug("[Attempt ##{retries}] Retrying because [#{exception.class} - #{exception.message}]: #{exception.backtrace.first(5).join(' | ')}")
+          end
+        end
+
+        expect { retryable.call }.to output(/\[Attempt #1\] Retrying because \[StandardError - because foo\]/).to_stdout_from_any_process
+      end
+    end
+  end
+end
+

data/spec/retryable_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require 'timeout'
+
+RSpec.describe Retryable do
+  describe '.retryable' do
+    before do
+      described_class.enable
+      @attempt = 0
+    end
+
+    it 'catch StandardError only by default' do
+      expect do
+        counter(tries: 2) { |tries| raise Exception if tries < 1 }
+      end.to raise_error Exception
+      expect(counter.count).to eq(1)
+    end
+
+    it 'retries on default exception' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+
+      counter(tries: 2) { |tries| raise StandardError if tries < 1 }
+      expect(counter.count).to eq(2)
+    end
+
+    it 'does not retry if disabled' do
+      described_class.disable
+
+      expect do
+        counter(tries: 2) { raise }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'executes *ensure* clause' do
+      ensure_cb = proc do |retries|
+        expect(retries).to eq(0)
+      end
+
+      described_class.retryable(ensure: ensure_cb) {}
+    end
+
+    it 'passes retry count and exception on retry' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+
+      counter(tries: 2) do |tries, ex|
+        expect(ex.class).to eq(StandardError) if tries > 0
+        raise StandardError if tries < 1
+      end
+      expect(counter.count).to eq(2)
+    end
+
+    it 'makes another try if exception is covered by :on' do
+      allow(Kernel).to receive(:sleep)
+      counter(on: [StandardError, ArgumentError, RuntimeError]) do |tries|
+        raise ArgumentError if tries < 1
+      end
+      expect(counter.count).to eq(2)
+    end
+
+    it 'does not retry on :not exception which is covered by Array' do
+      expect do
+        counter(not: [RuntimeError, IndexError]) { |tries| raise RuntimeError if tries < 1 }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'does not try on unexpected exception' do
+      allow(Kernel).to receive(:sleep)
+      expect do
+        counter(on: RuntimeError) { |tries| raise StandardError if tries < 1 }
+      end.to raise_error StandardError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'retries three times' do
+      allow(Kernel).to receive(:sleep)
+      counter(tries: 3) { |tries| raise StandardError if tries < 2 }
+      expect(counter.count).to eq(3)
+    end
+
+    context 'infinite retries' do
+      example 'with magic constant' do
+        expect do
+          Timeout.timeout(3) do
+            counter(tries: :infinite, sleep: 0.1) { raise StandardError }
+          end
+        end.to raise_error Timeout::Error
+
+        expect(counter.count).to be > 10
+      end
+
+      example 'with native infinity data type' do
+        expect do
+          require 'bigdecimal'
+
+          tries = [Float::INFINITY, BigDecimal::INFINITY, BigDecimal("1.0") / BigDecimal("0.0")]
+          Timeout.timeout(3) do
+            counter(tries: tries.sample, sleep: 0.1) { raise StandardError }
+          end
+        end.to raise_error Timeout::Error
+
+        expect(counter.count).to be > 10
+      end
+    end
+
+    it 'executes exponential backoff scheme for :sleep option' do
+      [1, 4, 16, 64].each { |i| expect(Kernel).to receive(:sleep).once.ordered.with(i) }
+      expect do
+        described_class.retryable(tries: 5, sleep: ->(n) { 4**n }) { raise RangeError }
+      end.to raise_error RangeError
+    end
+
+    it 'calls :sleep_method option' do
+      sleep_method = double
+      expect(sleep_method).to receive(:call).twice
+      expect do
+        described_class.retryable(tries: 3, sleep_method: sleep_method) { |tries| raise RangeError if tries < 9 }
+      end.to raise_error RangeError
+    end
+
+    it 'does not retry any exception if :on is empty list' do
+      expect do
+        counter(on: []) { raise }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'catches an exception that matches the regex' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+      counter(matching: /IO timeout/) { |c, _e| raise 'yo, IO timeout!' if c == 0 }
+      expect(counter.count).to eq(2)
+    end
+
+    it 'does not catch an exception that does not match the regex' do
+      expect(Kernel).not_to receive(:sleep)
+      expect do
+        counter(matching: /TimeError/) { raise 'yo, IO timeout!' }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'catches an exception in the list of matches' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+      counter(matching: [/IO timeout/, 'IO tymeout']) { |c, _e| raise 'yo, IO timeout!' if c == 0 }
+      expect(counter.count).to eq(2)
+
+      expect(Kernel).to receive(:sleep).once.with(1)
+      counter(matching: [/IO timeout/, 'IO tymeout']) { |c, _e| raise 'yo, IO tymeout!' if c == 0 }
+      expect(counter.count).to eq(4)
+    end
+
+    it 'does not allow invalid type of matching option' do
+      expect do
+        described_class.retryable(matching: 1) { raise 'this is invaid type of matching iotion' }
+      end.to raise_error ArgumentError, ':matching must be a string or regex'
+    end
+
+    it 'does not allow invalid options' do
+      expect do
+        described_class.retryable(bad_option: 2) { raise 'this is bad' }
+      end.to raise_error ArgumentError, '[Retryable] Invalid options: bad_option'
+    end
+
+    # rubocop:disable Rspec/InstanceVariable
+    it 'accepts a callback to run after an exception is rescued' do
+      expect do
+        described_class.retryable(sleep: 0, exception_cb: proc { |e| @raised = e.to_s }) do |tries|
+          raise StandardError, 'this is fun!' if tries < 1
+        end
+      end.not_to raise_error
+
+      expect(@raised).to eq('this is fun!')
+    end
+    # rubocop:enable Rspec/InstanceVariable
+
+    it 'does not retry on :not exception' do
+      expect do
+        counter(not: RuntimeError) { |tries| raise RuntimeError if tries < 1 }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'gives precidence for :not over :on' do
+      expect do
+        counter(sleep: 0, tries: 3, on: StandardError, not: IndexError) do |tries|
+          raise tries >= 1 ? IndexError : StandardError
+        end
+      end.to raise_error IndexError
+      expect(counter.count).to eq(2)
+    end
+  end
+end

data/spec/retryable_with_context_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe Retryable do
+  describe '.with_context' do
+    before do
+      described_class.enable
+      @attempt = 0
+    end
+
+    it 'properly checks context configuration' do
+      expect do
+        described_class.with_context(:foo) {}
+      end.to raise_error ArgumentError, 'foo not found in Retryable.configuration.contexts. Available contexts: []'
+
+      expect do
+        described_class.retryable_with_context(:bar) {}
+      end.to raise_error ArgumentError, 'bar not found in Retryable.configuration.contexts. Available contexts: []'
+
+      expect do
+        described_class.configure do |config|
+          config.contexts[:faulty_service] = {
+            sleep: 3
+          }
+        end
+
+        described_class.retryable_with_context(:baz) {}
+      end.to raise_error ArgumentError, 'baz not found in Retryable.configuration.contexts. Available contexts: [:faulty_service]'
+    end
+
+    it 'properly fetches context options' do
+      allow(Kernel).to receive(:sleep)
+
+      described_class.configure do |config|
+        config.contexts[:faulty_service] = {
+          tries: 3
+        }
+      end
+
+      c = counter_with_context(:faulty_service) { |tries| raise StandardError if tries < 2 }
+      expect(c.count).to eq(3)
+    end
+
+    it 'properly overrides context options with local arguments' do
+      allow(Kernel).to receive(:sleep)
+
+      described_class.configure do |config|
+        config.contexts[:faulty_service] = {
+          tries: 1
+        }
+      end
+
+      c = counter_with_context(:faulty_service, tries: 3) { |tries| raise StandardError if tries < 2 }
+      expect(c.count).to eq(3)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,25 +1,18 @@
-require File.dirname(__FILE__) + '/../lib/retryable'
-require 'rspec'
-require 'pry'
+require 'retryable'
+require 'simplecov'
 
-RSpec.configure do |config|
-  config.disable_monkey_patching!
+# rubocop:disable Style/ExpandPathArguments
+Dir.glob(File.expand_path('../support/**/*.rb', __FILE__), &method(:require))
+# rubocop:enable Style/ExpandPathArguments
 
-  config.before(:each) do
-    reset_config
-  end
+SimpleCov.start
 
-  def count_retryable(*opts)
-    @try_count = 0
-    return Retryable.retryable(*opts) do |*args|
-      @try_count += 1
-      yield *args
-    end
-  end
+RSpec.configure do |config|
+  config.disable_monkey_patching!
 
-  private
+  config.include(Counter)
 
-  def reset_config
+  config.before do
     Retryable.configuration = nil
   end
 end

data/spec/support/counter.rb

@@ -0,0 +1,58 @@
+module Counter
+  class PlainGenerator
+    attr_reader :count
+
+    def initialize(options)
+      @options = options
+      @count = 0
+    end
+
+    def around
+      Retryable.retryable(@options) do |*arguments|
+        increment
+        yield(*arguments)
+      end
+    end
+
+    private
+
+    def increment
+      @count += 1
+    end
+  end
+
+  class GeneratorWithContext
+    attr_reader :count
+
+    def initialize(context_key, options)
+      @context_key = context_key
+      @count = 0
+      @options = options
+    end
+
+    def around
+      Retryable.with_context(@context_key, @options) do |*arguments|
+        increment
+        yield(*arguments)
+      end
+    end
+
+    private
+
+    def increment
+      @count += 1
+    end
+  end
+
+  def counter(options = {}, &block)
+    @counter ||= PlainGenerator.new(options)
+    @counter.around(&block) if block_given?
+    @counter
+  end
+
+  def counter_with_context(context_key, options = {}, &block)
+    @counter_with_context ||= GeneratorWithContext.new(context_key, options)
+    @counter_with_context.around(&block) if block_given?
+    @counter_with_context
+  end
+end

metadata

@@ -1,97 +1,84 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: retryable
-version: !ruby/object:Gem::Version 
-  hash: 7
-  prerelease: 
-  segments: 
-  - 2
-  - 0
-  - 4
-  version: 2.0.4
+version: !ruby/object:Gem::Version
+  version: 3.0.5
 platform: ruby
-authors: 
+authors:
 - Nikita Fedyashev
 - Carlo Zottmann
 - Chu Yeow
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2016-07-14 00:00:00 +03:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2019-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bundler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-description: Retryable#retryable, allow for retrying of code blocks.
-email: nfedyashev@gmail.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Retrying code blocks in Ruby
+email:
+- nfedyashev@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - CHANGELOG.md
+- Gemfile
 - LICENSE.md
 - README.md
 - Rakefile
-- retryable.gemspec
+- lib/retryable.rb
 - lib/retryable/configuration.rb
 - lib/retryable/version.rb
-- lib/retryable.rb
-- spec/lib/configuration_spec.rb
-- spec/lib/retryable_spec.rb
+- retryable.gemspec
+- spec/retryable/configuration_spec.rb
+- spec/retryable/version_spec.rb
+- spec/retryable_logging_spec.rb
+- spec/retryable_spec.rb
+- spec/retryable_with_context_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
+- spec/support/counter.rb
 homepage: http://github.com/nfedyashev/retryable
-licenses: 
+licenses:
 - MIT
+metadata:
+  changelog_uri: https://github.com/nfedyashev/retryable/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/nfedyashev/retryable/tree/master
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 23
-      segments: 
-      - 1
-      - 3
-      - 6
+    - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 3.0.3
 signing_key: 
-specification_version: 3
-summary: Retryable#retryable, allow for retrying of code blocks.
-test_files: 
-- spec/lib/configuration_spec.rb
-- spec/lib/retryable_spec.rb
+specification_version: 4
+summary: Retrying code blocks in Ruby
+test_files:
+- spec/retryable/configuration_spec.rb
+- spec/retryable/version_spec.rb
+- spec/retryable_logging_spec.rb
+- spec/retryable_spec.rb
+- spec/retryable_with_context_spec.rb
 - spec/spec_helper.rb
+- spec/support/counter.rb