interactor-strict 1.0.0

data/spec/integration_spec.rb

@@ -0,0 +1,1777 @@
+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"
+        end
+
+        before do
+          context.fail!
+          context.steps << :before
+        end
+
+        after do
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        end
+
+        after do
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors and the failed interactor" do
+      expect {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        end
+
+        def rollback
+          context.steps << :rollback3
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        end
+
+        def rollback
+          context.steps << :rollback4b
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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"
+        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 {
+        begin
+          organizer.call(context)
+        rescue
+          nil
+        end
+      }.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