interactor 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eef8d6afd5557c08a2400afb30b40209bb17fec5
-  data.tar.gz: 8513cec42b1bbb273b96803ec06cce6144a4078f
+  metadata.gz: 25b48da784666d96730a23662bfe915115ce6be9
+  data.tar.gz: 5c7b218d7ff5857fef8d1faf6ea9e596ac3d9d49
 SHA512:
-  metadata.gz: 856f697f4443750d4fe95473ca44674669a8148582c5bff2dbff5ecd46d4ff5626b42c216eb4247c909c4d9bba0511d5a8bbfb50f9a6432f23f88c2a40d6be9f
-  data.tar.gz: 3ebed0429d15e0d9faa85d345523e0f0d9c3adf90ece48c0105761f8fbc1aea833fa718f07c2a362e194499bae18f79fe1309c14d55d720b6c9183c8a576326a
+  metadata.gz: 8df8db25f4fd3c5dee6fee8d4440480539886d244fdb8dc19365ced9b506875966e3347cf5a4cd579042037c66242bc019961797f938d46518e701952b1edb73
+  data.tar.gz: b5f3f10d429f80c5f13f7bd5bc0a0c886440de435583fad49c57e28e145d2e6bb3c0085b2909077d58531d42d4cf07f7ab95bc82ca8a04fe3dbd675006e26ab1

data/README.md

@@ -108,8 +108,100 @@ after do
 end
 ```
 
-**NOTE:** An interactor can define multiple before/after hooks, allowing common
-hooks to be extracted into interactor concerns.
+#### Around Hooks
+
+You can also define around hooks in the same way as before or after hooks, using
+either a block or a symbol method name. The difference is that an around block
+or method accepts a single argument. Invoking the `call` method on that argument
+will continue invocation of the interactor. For example, with a block:
+
+```ruby
+around do |interactor|
+  context.start_time = Time.now
+  interactor.call
+  context.finish_time = Time.now
+end
+```
+
+With a method:
+
+```ruby
+around :time_execution
+
+def time_execution(interactor)
+  context.start_time = Time.now
+  interactor.call
+  context.finish_time = Time.now
+end
+```
+
+#### Hook Sequence
+
+Before hooks are invoked in the order in which they were defined while after
+hooks are invoked in the opposite order. Around hooks are invoked outside of any
+defined before and after hooks. For example:
+
+```ruby
+around do |interactor|
+  puts "around before 1"
+  interactor.call
+  puts "around after 1"
+end
+
+around do |interactor|
+  puts "around before 2"
+  interactor.call
+  puts "around after 2"
+end
+
+before do
+  puts "before 1"
+end
+
+before do
+  puts "before 2"
+end
+
+after do
+  puts "after 1"
+end
+
+after do
+  puts "after 2"
+end
+```
+
+will output:
+
+```
+around before 1
+around before 2
+before 1
+before 2
+after 2
+after 1
+around after 2
+around after 1
+```
+
+#### Interactor Concerns
+
+An interactor can define multiple before/after hooks, allowing common hooks to
+be extracted into interactor concerns.
+
+```ruby
+module InteractorTimer
+  extend ActiveSupport::Concern
+
+  included do
+    around do |interactor|
+      context.start_time = Time.now
+      interactor.call
+      context.finish_time = Time.now
+    end
+  end
+end
+```
 
 ### An Example Interactor
 
@@ -375,7 +467,7 @@ class AuthenticateUser
 
   def call
     if user = User.authenticate(context.email, context.password)
-      context.user. = user
+      context.user = user
       context.token = user.secret_token
     else
       context.fail!(message: "authenticate_user.failure")
@@ -390,7 +482,7 @@ context.
 ```ruby
 describe AuthenticateUser do
   describe "#call" do
- end
+
     let(:interactor) { AuthenticateUser.new(email: "john@example.com", password: "secret") }
     let(:context) { interactor.context }
 

data/interactor.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name    = "interactor"
-  spec.version = "3.0.1"
+  spec.version = "3.1.0"
 
   spec.author      = "Collective Idea"
   spec.email       = "info@collectiveidea.com"

data/lib/interactor/hooks.rb

@@ -10,6 +10,49 @@ module Interactor
 
     # Internal: Interactor::Hooks class methods.
     module ClassMethods
+      # Public: Declare hooks to run around Interactor invocation. The around
+      # method may be called multiple times; subsequent calls append declared
+      # hooks to existing around hooks.
+      #
+      # hooks - Zero or more Symbol method names representing instance methods
+      #         to be called around interactor invocation. Each instance method
+      #         invocation receives an argument representing the next link in
+      #         the around hook chain.
+      # block - An optional block to be executed as a hook. If given, the block
+      #         is executed after methods corresponding to any given Symbols.
+      #
+      # Examples
+      #
+      #   class MyInteractor
+      #     include Interactor
+      #
+      #     around :time_execution
+      #
+      #     around do |interactor|
+      #       puts "started"
+      #       interactor.call
+      #       puts "finished"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #
+      #     private
+      #
+      #     def time_execution(interactor)
+      #       context.start_time = Time.now
+      #       interactor.call
+      #       context.finish_time = Time.now
+      #     end
+      #   end
+      #
+      # Returns nothing.
+      def around(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| around_hooks.push(hook) }
+      end
+
       # Public: Declare hooks to run before Interactor invocation. The before
       # method may be called multiple times; subsequent calls append declared
       # hooks to existing before hooks.
@@ -84,6 +127,25 @@ module Interactor
         hooks.each { |hook| after_hooks.unshift(hook) }
       end
 
+      # Internal: An Array of declared hooks to run around Interactor
+      # invocation. The hooks appear in the order in which they will be run.
+      #
+      # Examples
+      #
+      #   class MyInteractor
+      #     include Interactor
+      #
+      #     around :time_execution, :use_transaction
+      #   end
+      #
+      #   MyInteractor.around_hooks
+      #   # => [:time_execution, :use_transaction]
+      #
+      # Returns an Array of Symbols and Procs.
+      def around_hooks
+        @around_hooks ||= []
+      end
+
       # Internal: An Array of declared hooks to run before Interactor
       # invocation. The hooks appear in the order in which they will be run.
       #
@@ -125,7 +187,7 @@ module Interactor
 
     private
 
-    # Internal: Run before and after hooks around yielded execution. The
+    # Internal: Run around, before and after hooks around yielded execution. The
     # required block is surrounded with hooks and executed.
     #
     # Examples
@@ -146,9 +208,20 @@ module Interactor
     #
     # Returns nothing.
     def with_hooks
-      run_before_hooks
-      yield
-      run_after_hooks
+      run_around_hooks do
+        run_before_hooks
+        yield
+        run_after_hooks
+      end
+    end
+
+    # Internal: Run around hooks.
+    #
+    # Returns nothing.
+    def run_around_hooks(&block)
+      self.class.around_hooks.reverse.inject(block) { |chain, hook|
+        proc { run_hook(hook, chain) }
+      }.call
     end
 
     # Internal: Run before hooks.
@@ -181,10 +254,13 @@ module Interactor
     # proc, the proc is evaluated in the context of the current instance.
     #
     # hook - A Symbol or Proc hook.
+    # args - Zero or more arguments to be passed as block arguments into the
+    #        given block or as arguments into the method described by the given
+    #        Symbol method name.
     #
     # Returns nothing.
-    def run_hook(hook)
-      hook.is_a?(Symbol) ? send(hook) : instance_eval(&hook)
+    def run_hook(hook, *args)
+      hook.is_a?(Symbol) ? send(hook, *args) : instance_exec(*args, &hook)
     end
   end
 end

data/spec/integration_spec.rb

@@ -26,6 +26,12 @@ describe "Integration" do
 
   let(:organizer) {
     build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+      around do |interactor|
+        context.steps << :around_before
+        interactor.call
+        context.steps << :around_after
+      end
+
       before do
         context.steps << :before
       end
@@ -38,6 +44,12 @@ describe "Integration" do
 
   let(:organizer2) {
     build_organizer(organize: [interactor2a, interactor2b, interactor2c]) do
+      around do |interactor|
+        context.steps << :around_before2
+        interactor.call
+        context.steps << :around_after2
+      end
+
       before do
         context.steps << :before2
       end
@@ -50,6 +62,12 @@ describe "Integration" do
 
   let(:interactor2a) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before2a
+        interactor.call
+        context.steps << :around_after2a
+      end
+
       before do
         context.steps << :before2a
       end
@@ -70,6 +88,12 @@ describe "Integration" do
 
   let(:interactor2b) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before2b
+        interactor.call
+        context.steps << :around_after2b
+      end
+
       before do
         context.steps << :before2b
       end
@@ -90,6 +114,12 @@ describe "Integration" do
 
   let(:interactor2c) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before2c
+        interactor.call
+        context.steps << :around_after2c
+      end
+
       before do
         context.steps << :before2c
       end
@@ -110,6 +140,12 @@ describe "Integration" do
 
   let(:interactor3) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before3
+        interactor.call
+        context.steps << :around_after3
+      end
+
       before do
         context.steps << :before3
       end
@@ -130,6 +166,12 @@ describe "Integration" do
 
   let(:organizer4) {
     build_organizer(organize: [interactor4a, interactor4b, interactor4c]) do
+      around do |interactor|
+        context.steps << :around_before4
+        interactor.call
+        context.steps << :around_after4
+      end
+
       before do
         context.steps << :before4
       end
@@ -142,6 +184,12 @@ describe "Integration" do
 
   let(:interactor4a) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before4a
+        interactor.call
+        context.steps << :around_after4a
+      end
+
       before do
         context.steps << :before4a
       end
@@ -162,6 +210,12 @@ describe "Integration" do
 
   let(:interactor4b) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before4b
+        interactor.call
+        context.steps << :around_after4b
+      end
+
       before do
         context.steps << :before4b
       end
@@ -182,6 +236,12 @@ describe "Integration" do
 
   let(:interactor4c) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before4c
+        interactor.call
+        context.steps << :around_after4c
+      end
+
       before do
         context.steps << :before4c
       end
@@ -202,6 +262,12 @@ describe "Integration" do
 
   let(:interactor5) {
     build_interactor do
+      around do |interactor|
+        context.steps << :around_before5
+        interactor.call
+        context.steps << :around_after5
+      end
+
       before do
         context.steps << :before5
       end
@@ -220,7 +286,7 @@ describe "Integration" do
     end
   }
 
-  let(:context) { Interactor::Context.build(steps: []) }
+  let(:context) { Interactor::Context.new(steps: []) }
 
   context "when successful" do
     it "calls and runs hooks in the proper sequence" do
@@ -229,27 +295,34 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b, :call4b, :after4b,
-            :before4c, :call4c, :after4c,
-          :after4,
-          :before5, :call5, :after5,
-        :after
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
+        :after, :around_after
       ])
     end
   end
 
-  context "when a before hook fails" do
+  context "when an around hook fails early" do
     let(:organizer) {
       build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.fail!
+          context.steps << :around_before
+          interactor.call
+          context.steps << :around_after
+        end
+
         before do
           context.fail!
           context.steps << :before
@@ -270,11 +343,18 @@ describe "Integration" do
     end
   end
 
-  context "when a before hook errors" do
+  context "when an around hook errors early" do
     let(:organizer) {
       build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
-        before do
+        around do |interactor|
           raise "foo"
+          context.steps << :around_before
+          interactor.call
+          context.steps << :around_after
+        end
+
+        before do
+          context.fail!
           context.steps << :before
         end
 
@@ -299,9 +379,83 @@ describe "Integration" do
     end
   end
 
+  context "when a before hook fails" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.steps << :around_before
+          interactor.call
+          context.steps << :around_after
+        end
+
+        before do
+          context.fail!
+          context.steps << :before
+        end
+
+        after do
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before
+      ])
+    end
+  end
+
+  context "when a before hook errors" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.steps << :around_before
+          interactor.call
+          context.steps << :around_after
+        end
+
+        before do
+          raise "foo"
+          context.steps << :before
+        end
+
+        after do
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
   context "when an after hook fails" do
     let(:organizer) {
       build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.steps << :around_before
+          interactor.call
+          context.steps << :around_after
+        end
+
         before do
           context.steps << :before
         end
@@ -313,25 +467,25 @@ describe "Integration" do
       end
     }
 
-    it "rolls back successfully called interactors" do
+    it "rolls back successfully called interactors and the failed interactor" do
       expect {
         organizer.call(context)
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b, :call4b, :after4b,
-            :before4c, :call4c, :after4c,
-          :after4,
-          :before5, :call5, :after5,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
         :rollback5,
         :rollback4c,
         :rollback4b,
@@ -347,6 +501,12 @@ describe "Integration" do
   context "when an after hook errors" do
     let(:organizer) {
       build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.steps << :around_before
+          interactor.call
+          context.steps << :around_after
+        end
+
         before do
           context.steps << :before
         end
@@ -358,25 +518,25 @@ describe "Integration" do
       end
     }
 
-    it "aborts" do
+    it "rolls back successfully called interactors and the failed interactor" do
       expect {
         organizer.call(context) rescue nil
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b, :call4b, :after4b,
-            :before4c, :call4c, :after4c,
-          :after4,
-          :before5, :call5, :after5,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
         :rollback5,
         :rollback4c,
         :rollback4b,
@@ -395,40 +555,51 @@ describe "Integration" do
     end
   end
 
-  context "when a nested before hook fails" do
-    let(:interactor3) {
-      build_interactor do
-        before do
+  context "when an around hook fails late" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.steps << :around_before
+          interactor.call
           context.fail!
-          context.steps << :before3
-        end
-
-        after do
-          context.steps << :after3
+          context.steps << :around_after
         end
 
-        def call
-          context.steps << :call3
+        before do
+          context.steps << :before
         end
 
-        def rollback
-          context.steps << :rollback3
+        after do
+          context.steps << :after
         end
       end
     }
 
-    it "rolls back successfully called interactors" do
+    it "rolls back successfully called interactors and the failed interactor" do
       expect {
         organizer.call(context)
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
+        :after,
+        :rollback5,
+        :rollback4c,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -436,40 +607,51 @@ describe "Integration" do
     end
   end
 
-  context "when a nested before hook errors" do
-    let(:interactor3) {
-      build_interactor do
-        before do
+  context "when an around hook errors late" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        around do |interactor|
+          context.steps << :around_before
+          interactor.call
           raise "foo"
-          context.steps << :before3
-        end
-
-        after do
-          context.steps << :after3
+          context.steps << :around_after
         end
 
-        def call
-          context.steps << :call3
+        before do
+          context.steps << :before
         end
 
-        def rollback
-          context.steps << :rollback3
+        after do
+          context.steps << :after
         end
       end
     }
 
-    it "rolls back successfully called interactors" do
+    it "rolls back successfully called interactors and the failed interactor" do
       expect {
         organizer.call(context) rescue nil
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
+        :after,
+        :rollback5,
+        :rollback4c,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -483,9 +665,16 @@ describe "Integration" do
     end
   end
 
-  context "when a nested call fails" do
+  context "when a nested around hook fails early" do
     let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.fail!
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
           context.steps << :before3
         end
@@ -495,7 +684,6 @@ describe "Integration" do
         end
 
         def call
-          context.fail!
           context.steps << :call3
         end
 
@@ -511,13 +699,12 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -525,9 +712,16 @@ describe "Integration" do
     end
   end
 
-  context "when a nested call errors" do
+  context "when a nested around hook errors early" do
     let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          raise "foo"
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
           context.steps << :before3
         end
@@ -537,7 +731,6 @@ describe "Integration" do
         end
 
         def call
-          raise "foo"
           context.steps << :call3
         end
 
@@ -553,13 +746,12 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -573,15 +765,21 @@ describe "Integration" do
     end
   end
 
-  context "when a nested after hook fails" do
+  context "when a nested before hook fails" do
     let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
+          context.fail!
           context.steps << :before3
         end
 
         after do
-          context.fail!
           context.steps << :after3
         end
 
@@ -595,20 +793,19 @@ describe "Integration" do
       end
     }
 
-    it "rolls back successfully called interactors and the failed interactor" do
+    it "rolls back successfully called interactors" do
       expect {
         organizer.call(context)
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3,
-        :rollback3,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -616,15 +813,21 @@ describe "Integration" do
     end
   end
 
-  context "when a nested after hook errors" do
+  context "when a nested before hook errors" do
     let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
+          raise "foo"
           context.steps << :before3
         end
 
         after do
-          raise "foo"
           context.steps << :after3
         end
 
@@ -638,20 +841,19 @@ describe "Integration" do
       end
     }
 
-    it "rolls back successfully called interactors and the failed interactor" do
+    it "rolls back successfully called interactors" do
       expect {
         organizer.call(context) rescue nil
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3,
-        :rollback3,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -665,24 +867,30 @@ describe "Integration" do
     end
   end
 
-  context "when a deeply nested before hook fails" do
-    let(:interactor4b) {
+  context "when a nested call fails" do
+    let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
-          context.fail!
-          context.steps << :before4b
+          context.steps << :before3
         end
 
         after do
-          context.steps << :after4b
+          context.steps << :after3
         end
 
         def call
-          context.steps << :call4b
+          context.fail!
+          context.steps << :call3
         end
 
         def rollback
-          context.steps << :rollback4b
+          context.steps << :rollback3
         end
       end
     }
@@ -693,17 +901,13 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-        :rollback4a,
-        :rollback3,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -711,24 +915,30 @@ describe "Integration" do
     end
   end
 
-  context "when a deeply nested before hook errors" do
-    let(:interactor4b) {
+  context "when a nested call errors" do
+    let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
-          raise "foo"
-          context.steps << :before4b
+          context.steps << :before3
         end
 
         after do
-          context.steps << :after4b
+          context.steps << :after3
         end
 
         def call
-          context.steps << :call4b
+          raise "foo"
+          context.steps << :call3
         end
 
         def rollback
-          context.steps << :rollback4b
+          context.steps << :rollback3
         end
       end
     }
@@ -739,17 +949,13 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-        :rollback4a,
-        :rollback3,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3,
         :rollback2c,
         :rollback2b,
         :rollback2a
@@ -763,45 +969,47 @@ describe "Integration" do
     end
   end
 
-  context "when a deeply nested call fails" do
-    let(:interactor4b) {
+  context "when a nested after hook fails" do
+    let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
-          context.steps << :before4b
+          context.steps << :before3
         end
 
         after do
-          context.steps << :after4b
+          context.fail!
+          context.steps << :after3
         end
 
         def call
-          context.fail!
-          context.steps << :call4b
+          context.steps << :call3
         end
 
         def rollback
-          context.steps << :rollback4b
+          context.steps << :rollback3
         end
       end
     }
 
-    it "rolls back successfully called interactors" do
+    it "rolls back successfully called interactors and the failed interactor" do
       expect {
         organizer.call(context)
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b,
-        :rollback4a,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3,
         :rollback3,
         :rollback2c,
         :rollback2b,
@@ -810,45 +1018,47 @@ describe "Integration" do
     end
   end
 
-  context "when a deeply nested call errors" do
-    let(:interactor4b) {
+  context "when a nested after hook errors" do
+    let(:interactor3) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.steps << :around_after3
+        end
+
         before do
-          context.steps << :before4b
+          context.steps << :before3
         end
 
         after do
-          context.steps << :after4b
+          raise "foo"
+          context.steps << :after3
         end
 
         def call
-          raise "foo"
-          context.steps << :call4b
+          context.steps << :call3
         end
 
         def rollback
-          context.steps << :rollback4b
+          context.steps << :rollback3
         end
       end
     }
 
-    it "rolls back successfully called interactors" do
+    it "rolls back successfully called interactors and the failed interactor" do
       expect {
         organizer.call(context) rescue nil
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b,
-        :rollback4a,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3,
         :rollback3,
         :rollback2c,
         :rollback2b,
@@ -863,10 +1073,454 @@ describe "Integration" do
     end
   end
 
-  context "when a deeply nested after hook fails" do
-    let(:interactor4b) {
+  context "when a nested around hook fails late" do
+    let(:interactor3) {
       build_interactor do
-        before do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          context.fail!
+          context.steps << :around_after3
+        end
+
+        before do
+          context.steps << :before3
+        end
+
+        after do
+          context.steps << :after3
+        end
+
+        def call
+          context.steps << :call3
+        end
+
+        def rollback
+          context.steps << :rollback3
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors and the failed interactor" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a nested around hook errors late" do
+    let(:interactor3) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before3
+          interactor.call
+          raise "foo"
+          context.steps << :around_after3
+        end
+
+        before do
+          context.steps << :before3
+        end
+
+        after do
+          context.steps << :after3
+        end
+
+        def call
+          context.steps << :call3
+        end
+
+        def rollback
+          context.steps << :rollback3
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors and the failed interactor" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  context "when a deeply nested around hook fails early" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.fail!
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested around hook errors early" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          raise "foo"
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  context "when a deeply nested before hook fails" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.fail!
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested before hook errors" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
+          raise "foo"
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  context "when a deeply nested call fails" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.fail!
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested call errors" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          raise "foo"
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  context "when a deeply nested after hook fails" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
+        before do
           context.steps << :before4b
         end
 
@@ -891,16 +1545,16 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b, :call4b,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b,
         :rollback4b,
         :rollback4a,
         :rollback3,
@@ -914,6 +1568,12 @@ describe "Integration" do
   context "when a deeply nested after hook errors" do
     let(:interactor4b) {
       build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.steps << :around_after4b
+        end
+
         before do
           context.steps << :before4b
         end
@@ -939,16 +1599,130 @@ describe "Integration" do
       }.to change {
         context.steps
       }.from([]).to([
-        :before,
-          :before2,
-            :before2a, :call2a, :after2a,
-            :before2b, :call2b, :after2b,
-            :before2c, :call2c, :after2c,
-          :after2,
-          :before3, :call3, :after3,
-          :before4,
-            :before4a, :call4a, :after4a,
-            :before4b, :call4b,
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  context "when a deeply nested around hook fails late" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          context.fail!
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors and the failed interactor" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested around hook errors late" do
+    let(:interactor4b) {
+      build_interactor do
+        around do |interactor|
+          context.steps << :around_before4b
+          interactor.call
+          raise "foo"
+          context.steps << :around_after4b
+        end
+
+        before do
+          context.steps << :before4b
+        end
+
+        after do
+          context.steps << :after4b
+        end
+
+        def call
+          context.steps << :call4b
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors and the failed interactor" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :around_before, :before,
+          :around_before2, :before2,
+            :around_before2a, :before2a, :call2a, :after2a, :around_after2a,
+            :around_before2b, :before2b, :call2b, :after2b, :around_after2b,
+            :around_before2c, :before2c, :call2c, :after2c, :around_after2c,
+          :after2, :around_after2,
+          :around_before3, :before3, :call3, :after3, :around_after3,
+          :around_before4, :before4,
+            :around_before4a, :before4a, :call4a, :after4a, :around_after4a,
+            :around_before4b, :before4b, :call4b, :after4b,
         :rollback4b,
         :rollback4a,
         :rollback3,