functional_interactor 0.0.1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/functional_interactor.gemspec

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name    = "functional_interactor"
+  spec.version = "0.0.1"
+
+  spec.author      = "Ho-Sheng Hsiao"
+  spec.email       = "hosh@legal.io"
+  spec.description = "Functional Interactor using Kase protocol and composition operators"
+  spec.summary     = "Functional Interactor, composable, higher-order interactors. Complete rewrite of collectiveideas/interactor"
+  spec.homepage    = "https://github.com/hosh/functional_interactor"
+  spec.license     = "MIT"
+
+  spec.files      = `git ls-files`.split($/)
+  spec.test_files = spec.files.grep(/^spec/)
+
+  spec.add_dependency 'activesupport', '~>4.2'
+  #spec.add_dependency 'hosh-kase'
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.3"
+end

data/lib/functional_interactor.rb

@@ -0,0 +1,38 @@
+require 'active_support/concern'
+require 'interactors'
+
+# Include this to support interactor interface
+module FunctionalInteractor
+  extend ActiveSupport::Concern
+
+  included do
+    attr_reader :context # Probably don't need this anymore, just pass it into #call
+    alias_method :|, :compose
+  end
+
+  # | aliases to compose, so you can do something like:
+  # (CreateOrder | ChargeCard.new(token: params[:token]) | SendThankYou).call
+  def compose(interactor)
+    Interactors::Sequence.new.compose(self).compose(interactor)
+  end
+
+  alias_method :|, :compose
+
+  def call(context)
+    [:ok, context]
+  end
+
+  class_methods do
+    # | aliases to compose, so you can do something like:
+    # (CreateOrder | ChargeCard.new(token: params[:token]) | SendThankYou).call
+    def compose(interactor)
+      Interactors::Sequence.new.compose(self).compose(interactor)
+    end
+
+    alias_method :|, :compose
+
+    def call(context = {})
+      new.call(context)
+    end
+  end
+end

data/lib/interactors.rb

@@ -0,0 +1,12 @@
+require 'functional_interactor'
+
+module Interactors
+  autoload :Sequence,  'interactors/sequence'
+  autoload :Anonymous, 'interactors/anonymous'
+  autoload :Simple,    'interactors/simple'
+
+  # Helper
+  def self.new(&blk)
+    Interactors::Anonymous.new(&blk)
+  end
+end

data/lib/interactors/anonymous.rb

@@ -0,0 +1,20 @@
+require 'interactor'
+
+module Interactors
+  # Anonymous interactors
+  # Does two things:
+  #  - passes context to the proc
+  #  - honors #compose interface
+  class Anonymous
+    include FunctionalInteractor
+    attr_reader :block
+
+    def initialize(&blk)
+      @block = blk
+    end
+
+    def call(context = {})
+      block.call(context)
+    end
+  end
+end

data/lib/interactors/sequence.rb

@@ -0,0 +1,28 @@
+require 'interactor'
+
+module Interactors
+  # An Interactor that is a sequence of Interactors
+  class Sequence
+    include FunctionalInteractor
+    include Kase
+
+    def interactions
+      @__interactions ||= []
+    end
+
+    def compose(interactor)
+      interactions << interactor
+      self
+    end
+
+    def call(context = {})
+      interactions.each do |interactor|
+        results = interactor.call(context)
+        next if results[0] == :ok
+        return results if results[0] == :error
+        raise ArgumentError, "Return value from interactor must be [:ok, context] or [:error, ...]"
+      end
+      [:ok, context]
+    end
+  end
+end

data/lib/interactors/simple.rb

@@ -0,0 +1,35 @@
+require 'interactor'
+
+module Interactors
+  # Anonymous interactors
+  # Does two things:
+  #  - passes context to the proc
+  #  - honors #compose interface
+  #  - Only return [:error, ... ] if exception is raised
+  #  - otherwise, always return [:ok, context]
+  class Simple
+    include FunctionalInteractor
+    attr_reader :block
+
+    def initialize(&blk)
+      @block = blk
+    end
+
+    def call(context = {})
+      handle_error do
+        block.call(context)
+      end
+    end
+
+    # This is meant to be overridable. Maybe you
+    # want to use something else, such as capturing
+    # network errors, or wrap around specific third-party
+    # libraries.
+    def handle_error
+      yield
+      [:ok, context]
+    rescue Exception => e
+      [:error, e]
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,1741 @@
+describe "Integration" do
+  def build_interactor(&block)
+    interactor = Class.new.send(:include, Interactor)
+    interactor.class_eval(&block) if block
+    interactor
+  end
+
+  def build_organizer(options = {}, &block)
+    organizer = Class.new.send(:include, Interactor::Organizer)
+    organizer.organize(options[:organize]) if options[:organize]
+    organizer.class_eval(&block) if block
+    organizer
+  end
+
+  # organizer
+  #  ├─ organizer2
+  #  │   ├─ interactor2a
+  #  │   ├─ interactor2b
+  #  │   └─ interactor2c
+  #  ├─ interactor3
+  #  ├─ organizer4
+  #  │   ├─ interactor4a
+  #  │   ├─ interactor4b
+  #  │   └─ interactor4c
+  #  └─ interactor5
+
+  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
+
+      after do
+        context.steps << :after
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after2
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after2a
+      end
+
+      def call
+        context.steps << :call2a
+      end
+
+      def rollback
+        context.steps << :rollback2a
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after2b
+      end
+
+      def call
+        context.steps << :call2b
+      end
+
+      def rollback
+        context.steps << :rollback2b
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after2c
+      end
+
+      def call
+        context.steps << :call2c
+      end
+
+      def rollback
+        context.steps << :rollback2c
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after3
+      end
+
+      def call
+        context.steps << :call3
+      end
+
+      def rollback
+        context.steps << :rollback3
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after4
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after4a
+      end
+
+      def call
+        context.steps << :call4a
+      end
+
+      def rollback
+        context.steps << :rollback4a
+      end
+    end
+  }
+
+  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.steps << :call4b
+      end
+
+      def rollback
+        context.steps << :rollback4b
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after4c
+      end
+
+      def call
+        context.steps << :call4c
+      end
+
+      def rollback
+        context.steps << :rollback4c
+      end
+    end
+  }
+
+  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
+
+      after do
+        context.steps << :after5
+      end
+
+      def call
+        context.steps << :call5
+      end
+
+      def rollback
+        context.steps << :rollback5
+      end
+    end
+  }
+
+  let(:context) { Interactor::Context.new(steps: []) }
+
+  context "when successful" do
+    it "calls and runs hooks in the proper sequence" 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, :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 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
+        end
+
+        after do
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        organizer.call(context)
+      }.not_to change {
+        context.steps
+      }
+    end
+  end
+
+  context "when an around hook errors early" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) 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
+
+        after do
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        organizer.call(context) rescue nil
+      }.not_to change {
+        context.steps
+      }
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    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
+
+        after do
+          context.fail!
+          context.steps << :after
+        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, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
+        :rollback5,
+        :rollback4c,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  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
+
+        after do
+          raise "foo"
+          context.steps << :after
+        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, :around_after4b,
+            :around_before4c, :before4c, :call4c, :after4c, :around_after4c,
+          :after4, :around_after4,
+          :around_before5, :before5, :call5, :after5, :around_after5,
+        :rollback5,
+        :rollback4c,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  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 << :around_after
+        end
+
+        before do
+          context.steps << :before
+        end
+
+        after do
+          context.steps << :after
+        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, :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
+      ])
+    end
+  end
+
+  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 << :around_after
+        end
+
+        before do
+          context.steps << :before
+        end
+
+        after do
+          context.steps << :after
+        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, :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
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  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
+
+        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" 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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  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
+
+        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" 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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  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.steps << :after3
+        end
+
+        def call
+          context.steps << :call3
+        end
+
+        def rollback
+          context.steps << :rollback3
+        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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  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
+          context.steps << :after3
+        end
+
+        def call
+          context.steps << :call3
+        end
+
+        def rollback
+          context.steps << :rollback3
+        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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  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.steps << :before3
+        end
+
+        after do
+          context.steps << :after3
+        end
+
+        def call
+          context.fail!
+          context.steps << :call3
+        end
+
+        def rollback
+          context.steps << :rollback3
+        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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  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
+          context.steps << :before3
+        end
+
+        after do
+          context.steps << :after3
+        end
+
+        def call
+          raise "foo"
+          context.steps << :call3
+        end
+
+        def rollback
+          context.steps << :rollback3
+        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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  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 << :before3
+        end
+
+        after do
+          context.fail!
+          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,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  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 << :before3
+        end
+
+        after do
+          raise "foo"
+          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,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+
+  context "when a nested around hook fails late" do
+    let(:interactor3) {
+      build_interactor 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
+
+        after do
+          context.fail!
+          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,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  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
+
+        after do
+          raise "foo"
+          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,
+        :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,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+end