recoverable 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef2d6b67667197eda7be6937a1852cd3479b8054
-  data.tar.gz: ba58fff01c7747b79285db1bcf1412470620c2a4
+  metadata.gz: 91d2cd9b2a88fc2cb068caa21ba39b4c6b2d7e15
+  data.tar.gz: 2eadd39119ec415d732ccff3b822e3c95ff96da1
 SHA512:
-  metadata.gz: a739f0dca356eb2bf9cb349b777be6aae48a4432399c9fd1ea3897e168dd1edb97ecdf8a6a662c36d85be388566857f51c1d5a0d3f6b403bad880655a2290115
-  data.tar.gz: acae59acb3450432c5abd0c5af29fc30c2f4852072f64798a3dcc17c99bfb033f66d4a524686c177f68f3c40ac3d84d3123f2188032183fdd1ee208b2144ec82
+  metadata.gz: b1fe4d4f02d158f7e0625d6282f382218b95d35e2ac753f8b7b802838bd5a68e1b023fed31934b28f762d10343ed399cdcd57d8ee6cb853aa022ee8d9f153aee
+  data.tar.gz: af71452c0b87834ba674960dbf8dc08e7110b4cb76237973600a31aefc998337f3991d4282ff000d0a0b91df407f6228a515fa79bf9352bdcf3ae591de566745

data/README.md

@@ -3,14 +3,137 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/dd436c45c8a52dc8c13c/maintainability)](https://codeclimate.com/github/Benjaminpjacobs/recoverable/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/dd436c45c8a52dc8c13c/test_coverage)](https://codeclimate.com/github/Benjaminpjacobs/recoverable/test_coverage)
 
-## Recoverbale
+## Recoverable
 
+Recoverable is a simple DSL that works at the class level to configure retries of instance methods. With a multitude of customizations this gem can combined with ruby's class inheritence can be a powerful tool for drying up code.
 
 ## Installation
 
+Install the gem: 
+
+```sh
+$ gem install 'recoverable'
+```
+
+Add it to your gemfile:
+
+```ruby
+gem 'recoverable'
+```
+
+Then run bundle to install the Gem:
+
+```sh
+$ bundle install
+```
 
 ## Usage
 
+Recoverable gives you a dynamic way to retry and handle errors on an instance of a class or an inherited class.
+
+### Default Behavior
+
+You can add recoverable to your class by simply extending the Gem and then telling it which method you would like to recover from and how many times you would like to retry.
+
+```ruby
+  class Foo
+    extend Recoverable
+    recover :bar, tries: 2
+
+    def bar
+      baz
+    end
+
+  end
+```
+With the above configuration any instance of `Foo` will recover any `StandardError` on `#bar` and retry 2 times without a sleep between retries. After the second retry it will raise the error `Recoverable::RetryCountExceeded` along with the information about what error had occured.
+
+### Configuration Options
+
+Recoverable allows for varied configurations to alter the behavior of the rescue and retry.
+
+#### Errors
+
+Setting up your class with the following will specifically recover on `CustomError`.
+
+```ruby
+  class Foo
+    extend Recoverable
+    recover :bar, tries: 2, on: CustomError
+
+    def bar
+      baz
+    end
+
+  end
+```
+Note that this configuration will on rescue and retry on CustomError and will not rescue any other error including `StandardError`.
+
+Recoverable can rescue on a collection of errors as well, however these must be passed to `on:` as an array.
+
+```ruby
+  recover :bar, tries: 2, on: [ CustomError, OtherCustomError ]
+```
+In the above case both `CustomError` and `OtherCustomError` will be rescued on the `#bar` method.
+
+#### Sleep
+
+Setting up your class with the following configuration will insert a 3 second sleep command between each retry:
+
+```ruby
+  class Foo
+    extend Recoverable
+    recover :bar, tries: 2, sleep: 3
+
+    def bar
+      baz
+    end
+
+  end
+```
+
+#### Custom Exception
+
+In addition to retrying, recoverable allows you to raise a custom exception after the rescue and retry attempts.
+
+```ruby
+
+  class MyException < StandardError; end
+
+  class Foo
+    extend Recoverable
+    recover :bar, tries: 2, custom_exception: MyException
+
+    def bar
+      baz
+    end
+
+  end
+```
+
+In this configuration after bar was retried twice recoverable would not raise `StandardError` or `Recoverable::RetryCountExceeded` but would instead raise `MyException`
+
+#### Custom Handler
+
+Recoverable also allows you to configure a custom error handling method. This should be a method defined on the class or parent class of the instance.
+
+```ruby
+  class Foo
+    extend Recoverable
+    recover :bar, tries: 2, custom_handler: :handle_error
+
+    def bar
+      baz
+    end
+
+    def handle_error(:error)
+      "#{error} was retried twice, raised and then this method was called."
+    end
+  end
+```
+
+Please note that the name of the handler method should be passed to the configuration as a symbol. Also, the handler method can take either no arguments or a single keyword argument for `error:` if you would like access to the error inside the handler. Any other data inside the handler should be retrieved via instance methods or instance variables.
+
 
 ## How to contribute
 

data/lib/recoverable/base.rb

@@ -1,27 +1,35 @@
 module Recoverable
-  def recover(method_name, tries: 1, on: StandardError, sleep: nil, custom_handler: nil, custom_exception: RetryCountExceeded)
+  def recover(method_name, tries: 1, on: StandardError, wait: nil, wait_method: nil,custom_handler: nil, throw: RetryCountExceeded)
     recoverable = Array.wrap(on)
-    proxy       = create_proxy(method_name: method_name, tries: tries, recoverable: recoverable, sleep: sleep, custom_handler: custom_handler, custom_exception: custom_exception)
+    proxy       = create_proxy(method_name: method_name, tries: tries, recoverable: recoverable, wait: wait, wait_method: wait_method, custom_handler: custom_handler, throw: throw)
     self.prepend proxy
   end
 
-  def create_proxy(method_name:, tries:, recoverable:, sleep:, custom_handler:, custom_exception:)
+  def create_proxy(method_name:, tries:, recoverable:, wait:, wait_method:, custom_handler:, throw:)
     Module.new do
       define_method(method_name) do |*args|
         retries = tries
         begin
           super *args
         rescue *recoverable => error
-          sleep(sleep) if sleep
+          self.class.handle_wait(wait, wait_method) if wait
           retry        if (retries -= 1) > 0
-          self.class.handle_exception(instance: self, custom_handler: custom_handler, args: args, error: error, custom_exception: custom_exception)
+          self.class.handle_exception(instance: self, custom_handler: custom_handler, args: args, error: error, throw: throw)
         end
       end
     end
   end
 
-  def handle_exception(instance:, custom_handler:, args:, error:, custom_exception: )
-    raise custom_exception.new(error) unless custom_handler
+  def handle_wait(wait, wait_method)
+    if wait_method
+      wait_method.call(wait)
+    else
+      Defaults.wait(wait)
+    end
+  end
+
+  def handle_exception(instance:, custom_handler:, args:, error:, throw: )
+    raise throw.new(error) unless custom_handler
     req_params = retrieve_required_parameters(instance, custom_handler)
 
     return instance.send(custom_handler) if req_params.empty?

data/lib/recoverable/default.rb

@@ -0,0 +1,13 @@
+module Recoverable
+  class Defaults
+    @wait_method = Proc.new{ |int| Kernel.sleep int }
+    class << self
+
+      attr_accessor :wait_method
+
+      def wait(int)
+        @wait_method.call(int)
+      end
+    end
+  end
+end

data/lib/recoverable/version.rb

@@ -1,3 +1,3 @@
 module Recoverable
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/recoverable.rb

@@ -4,6 +4,7 @@ require 'logger'
 
 # App
 require 'recoverable/errors'
+require 'recoverable/default'
 require 'recoverable/base'
 
 # Models

data/spec/mocks/test_errors.rb

@@ -0,0 +1,3 @@
+class CustomError < StandardError ; end
+class UnrecoveredError < StandardError ; end
+class AlternateCustomError < StandardError ; end

data/spec/recoverable_spec.rb

@@ -1,178 +1,475 @@
 require 'spec_helper'
 RSpec.describe Recoverable do
-  let!(:instance) { self.class::TestClass.new }
-  subject{ instance.bar }
-  context "passing no errors" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2
+  context "Recover Directly on Class" do
+    let!(:instance) { self.class::TestClass.new }
+    subject{ instance.bar }
+    context "With Basic Deafults" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2
 
-      def bar; baz; end
-      def baz; end
+        def bar; baz; end
+        def baz; end
 
-    end
+      end
 
-    it "defaults to standard error and no sleep" do
-      expect_any_instance_of(Kernel).to receive(:sleep).never
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
-      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
-    end
+      it "rescues on standard error and does not wait" do
+        expect_any_instance_of(Kernel).to receive(:sleep).never
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
 
-    it "recovers from inheritors of standard error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
-      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      it "rescues from inheritors of standard error" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
     end
 
-  end
+    context "Configured for a specific error to resuce" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2, on: CustomError
+
+        def bar; baz; end
+        def baz; end
 
-  context "passing specific errors" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2, on: CustomError
+      end
 
-      def bar; baz; end
-      def baz; end
+      it "rescues from that error" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
 
-    end
+      it "does not rescue from different raised error" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(UnrecoveredError)
+        expect{ subject }.to raise_error(UnrecoveredError)
+      end
 
-    it "recovers from specific error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
-      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      it "does not rescue from standard error" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
+        expect{ subject }.to raise_error(StandardError)
+      end
     end
 
-    it "does not recover from different raised error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(UnrecoveredError)
-      expect{ subject }.to raise_error(UnrecoveredError)
-    end
+    context "Cofigured to rescue multiple specific errors" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2, on: [CustomError, AlternateCustomError]
+
+        def bar; baz; end
+        def baz; end
 
-    it "does not recover from standard error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
-      expect{ subject }.to raise_error(StandardError)
+      end
+
+      it "rescues from error A" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
+
+      it "rescues from error B" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(AlternateCustomError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
+
+      it "does not rescue from different raised error" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(UnrecoveredError)
+        expect{ subject }.to raise_error(UnrecoveredError)
+      end
+
+      it "does not rescue from standard error" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
+        expect{ subject }.to raise_error(StandardError)
+      end
     end
 
-  end
+    context "Configured for custom wait time with defualt" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2, on: CustomError, wait: 3
+
+        def bar; baz; end
+        def baz; end
+
+      end
 
-  context "passing specific sleep" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2, on: CustomError, sleep: 3
+      it "sleeps for configured time" do
+        expect(Recoverable::Defaults.wait_method).to be_a(Proc)
+        expect(Kernel).to receive(:sleep).with(3).exactly(2).times
 
-      def bar; baz; end
-      def baz; end
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
 
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
     end
 
-    it "recovers from specific error" do
-      expect_any_instance_of(Kernel).to receive(:sleep).with(3).exactly(2).times
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
-      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+    context "Configured for custom wait time with new default waiter method" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2, on: CustomError, wait: 3
+
+        def bar; baz; end
+        def baz; end
+
+      end
+      let(:custom_waiter) { Proc.new{|int| p "Called Custom Default with arg: #{int}"} }
+
+      before(:each) do
+        Recoverable::Defaults.wait_method = custom_waiter
+      end
+
+      it "custom waiter method for configured time" do
+        expect(Recoverable::Defaults.wait_method).to eq(custom_waiter)
+        expect(Recoverable::Defaults).to receive(:wait).with(3).exactly(2).times.and_call_original
+
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
     end
-  end
 
-  context "passing custom error handler" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+    context "Configured for custom wait time with custom waiter method" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2, on: CustomError, wait: 3, wait_method: Proc.new{|int| p "Called Custom Waiter with arg: #{int}"}
+
+        def bar; baz; end
+        def baz; end
 
-      def bar; baz; end
-      def baz; end
-      def handle_error
-        "Handled"
       end
 
+      it "custom waiter method for configured time" do
+        expect(Recoverable::Defaults).to receive(:wait).never
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
     end
 
-    it "recovers from specific error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
-      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
-      expect(subject).to eq("Handled")
+    context "Configured to raise custom exception" do
+      class self::TestClass
+        class TestCustomExecption < StandardError; end
+        extend Recoverable
+        recover :bar, tries: 2, on: CustomError, throw: TestCustomExecption
+
+        def bar; baz; end
+        def baz; end
+
+      end
+
+      it "rescues error and raises custom exception" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+        expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+        expect{ subject }.to raise_error(self.class::TestClass::TestCustomExecption)
+      end
     end
-  end
-  
-  context "passing custom error handler with error message" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
 
-      def bar(arg:nil)
-        baz
+
+    context "Configured to use a custom error handling method" do
+      class self::TestClass
+        extend Recoverable
+        recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+
+        def bar; baz; end
+        def baz; end
+        def handle_error
+          "Handled"
+        end
+
+      end
+
+      it "recovers from configured error by running custom handler method" do
+        allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+        expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+        expect(subject).to eq("Handled")
       end
 
-      def baz; end
+      context "handler method utilizes returned error" do
+        class self::TestClass
+          extend Recoverable
+          recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+
+          def bar(arg:nil)
+            baz
+          end
+
+          def baz; end
 
-      def handle_error(error:)
-        error.message
+          def handle_error(error:)
+            error.message
+          end
+        end
+
+        subject { instance.bar}
+
+        it "has access to the raised error" do
+          allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError.new("Custom Error!"))
+          expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+          expect(subject).to eq("Custom Error!")
+        end
       end
 
-    end
+      context "handler method utilizes args" do
+        class self::TestClass
+          extend Recoverable
+          recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+
+          def bar(arg:nil)
+            baz
+          end
+
+          def baz; end
+
+          def handle_error(error:, arg:)
+            arg
+          end
+
+        end
+
+        subject { instance.bar(arg: "I'm a keyword Arg")}
+
+        it "has access to the keyword args" do
+          allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+          expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+          expect(subject).to eq("I'm a keyword Arg")
+        end
+      end
+
+      context "handler method utilizes other private and public instance methods" do
+        class self::TestClass
+          extend Recoverable
+          recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+
+          def bar(arg:nil)
+            baz
+          end
+
+          def baz; end
+
+          def handle_error(error:)
+            "#{method_call}, #{private_method_call}"
+          end
 
-    subject { instance.bar(arg: "I'm a keyword Arg")}
+          def method_call
+            "I'm a method call"
+          end
 
-    it "recovers from specific error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError.new("Custom Error!"))
-      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
-      expect(subject).to eq("Custom Error!")
+          private
+
+          def private_method_call
+            "I'm a private method call"
+          end
+        end
+
+        subject { instance.bar}
+
+        it "has access to private and public methods" do
+          allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+          expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+          expect(subject).to eq( "I'm a method call, I'm a private method call")
+        end
+      end
+
+      context "handler method utilizes instance variables" do
+        class self::TestClass
+          extend Recoverable
+          recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+          attr_reader :qux
+
+          def initialize
+            @qux = "I'm an instance variable"
+          end
+
+          def bar(arg:nil)
+            baz
+          end
+
+          def baz; end
+
+          def handle_error(error:)
+            "#{@qux}"
+          end
+
+        end
+
+        subject { instance.bar}
+
+        it "has access to instance variables" do
+          allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+          expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+          expect(subject).to eq( "I'm an instance variable")
+        end
+      end
     end
+
   end
 
-  context "passing custom error handler with arg" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+  context "Recover Through Inheritence" do
+    context 'Configuring recoverable on the parent class' do
+      class self::TestParentClass
+        extend Recoverable
+        recover :bar, tries: 2
+        def bar
+          baz
+        end
 
-      def bar(arg:nil)
-        baz
       end
 
-      def baz; end
+      class self::TestChildClass < self::TestParentClass
+        def bar
+          super
+        end
 
-      def handle_error(error:, arg:)
-        arg
+        def baz; end
       end
 
-    end
+      let!(:instance) { self.class::TestChildClass.new }
+      subject{ instance.bar }
+
+      it "can recover an error through inheritence chain" do
+        allow_any_instance_of(self.class::TestChildClass).to receive(:baz).and_raise(StandardError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
+
+      context "recovered method overridden on the child class" do
+        class self::TestParentClass
+          extend Recoverable
+          recover :bar, tries: 2
+
+          def bar
+            baz
+          end
+        end
+
+        class self::TestChildClass < self::TestParentClass
+          def bar
+            baz
+          end
 
-    subject { instance.bar(arg: "I'm a keyword Arg")}
+          def baz; end
+        end
 
-    it "recovers from specific error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
-      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
-      expect(subject).to eq("I'm a keyword Arg")
+        let!(:instance) { self.class::TestChildClass.new }
+        subject{ instance.bar }
+
+        it "will not recovers through inheritence chain" do
+          allow_any_instance_of(self.class::TestChildClass).to receive(:baz).and_raise(StandardError)
+          expect{ subject }.to raise_error(StandardError)
+        end
+      end
     end
-  end
 
-  context "passing custom error handler with a method call" do
-    class self::TestClass
-      extend Recoverable
-      recover :bar, tries: 2, on: CustomError, custom_handler: :handle_error
+    context 'Configuring recoverable on the parent class through multiple levels' do
+      class self::TestParentClass
+        extend Recoverable
+        recover :bar, tries: 2
+        def bar
+          baz
+        end
+
+      end
+
+      class self::TestChildClass < self::TestParentClass
+        def baz; end
+      end
 
-      def bar(arg:nil)
-        baz
+      class self::TestSubChildClass < self::TestChildClass
+        def bar
+          super
+        end
       end
 
-      def baz; end
+      let!(:instance) { self.class::TestSubChildClass.new }
+      subject{ instance.bar }
 
-      def handle_error(error:)
-        "#{method_call}, #{private_method_call}"
+      it "can recover through the inheritence chain" do
+        allow_any_instance_of(self.class::TestChildClass).to receive(:baz).and_raise(StandardError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
       end
+    end
 
-      def method_call
-        "I'm a method call"
+    context 'Configuring recoverable on child class' do
+      class self::TestParentClass
+        def bar
+          baz
+        end
       end
-      private
 
-      def private_method_call
-        "I'm a private method call"
+      class self::TestChildClass < self::TestParentClass
+        extend Recoverable
+        recover :bar, tries: 2
+        def baz; end
       end
 
+      let!(:instance) { self.class::TestChildClass.new }
+      subject{ instance.bar }
+
+      it "can recover through inheritence chain" do
+        allow_any_instance_of(self.class::TestChildClass).to receive(:baz).and_raise(StandardError)
+        expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+      end
     end
 
-    subject { instance.bar(arg: "I'm a keyword Arg")}
+    context "Handler Method" do
+      context "Handler method defined on the parent class" do
+        class self::TestParentClass
+          extend Recoverable
+          recover :bar, tries: 2, custom_handler: :handle_error
+
+          def bar
+            baz
+          end
+
+          def handle_error(error:)
+            "Parent Handler!"
+          end
+        end
+
+        class self::TestChildClass < self::TestParentClass
+          def baz; end
+        end
+
+        let!(:instance) { self.class::TestChildClass.new }
+        subject{ instance.bar }
+
+        it "calls handler from the parent class" do
+          allow_any_instance_of(self.class::TestChildClass).to receive(:baz).and_raise(StandardError)
+          expect{ subject }.to_not raise_error(StandardError)
+          expect(subject).to eq("Parent Handler!")
+        end
+      end
+
+      context "Handler method defined on the child class" do
+         class self::TestParentClass
+          extend Recoverable
+          recover :bar, tries: 2, custom_handler: :handle_error
+
+          def bar
+            baz
+          end
 
-    it "recovers from specific error" do
-      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
-      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
-      expect(subject).to eq( "I'm a method call, I'm a private method call")
+          def handle_error(error:)
+            "Parent Handler!"
+          end
+
+        end
+
+        class self::TestChildClass < self::TestParentClass
+          def baz; end
+
+          def handle_error(error:)
+            "Child Handler!"
+          end
+        end
+
+        let!(:instance) { self.class::TestChildClass.new }
+        subject{ instance.bar }
+
+        it "calls handler from child class" do
+          allow_any_instance_of(self.class::TestChildClass).to receive(:baz).and_raise(StandardError)
+          expect{ subject }.to_not raise_error(StandardError)
+          expect(subject).to eq("Child Handler!")
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -7,9 +7,7 @@ SimpleCov.start do
 end
 
 require 'recoverable'
-require 'mocks/foo'
-require 'mocks/custom_error'
-require 'mocks/unrecovered_error'
+require 'mocks/test_errors'
 require 'factory_bot'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recoverable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Ben Jacobs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-09 00:00:00.000000000 Z
+date: 2018-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: her
@@ -119,11 +119,10 @@ files:
 - README.md
 - lib/recoverable.rb
 - lib/recoverable/base.rb
+- lib/recoverable/default.rb
 - lib/recoverable/errors.rb
 - lib/recoverable/version.rb
-- spec/mocks/custom_error.rb
-- spec/mocks/foo.rb
-- spec/mocks/unrecovered_error.rb
+- spec/mocks/test_errors.rb
 - spec/recoverable_spec.rb
 - spec/spec_helper.rb
 homepage: 
@@ -151,8 +150,6 @@ signing_key:
 specification_version: 4
 summary: Class Level retry DSL for ruby
 test_files:
-- spec/mocks/foo.rb
-- spec/mocks/custom_error.rb
-- spec/mocks/unrecovered_error.rb
+- spec/mocks/test_errors.rb
 - spec/spec_helper.rb
 - spec/recoverable_spec.rb

data/spec/mocks/custom_error.rb

@@ -1 +0,0 @@
-class CustomError < StandardError; end

data/spec/mocks/foo.rb

@@ -1,10 +0,0 @@
-class Foo
-  extend Recoverable
-  
-  def bar
-    baz
-  end
-
-  def baz
-  end
-end

data/spec/mocks/unrecovered_error.rb

@@ -1 +0,0 @@
-class UnrecoveredError < StandardError; end