interactor 2.1.1 → 3.0.0

data/interactor.gemspec

@@ -2,19 +2,18 @@
 
 Gem::Specification.new do |spec|
   spec.name    = "interactor"
-  spec.version = "2.1.1"
+  spec.version = "3.0.0"
 
   spec.author      = "Collective Idea"
   spec.email       = "info@collectiveidea.com"
-  spec.description = "Interactor provides a common interface for performing complex interactions in a single request."
+  spec.description = "Interactor provides a common interface for performing complex user interactions."
   spec.summary     = "Simple interactor implementation"
   spec.homepage    = "https://github.com/collectiveidea/interactor"
   spec.license     = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
-  spec.test_files    = spec.files.grep(/^spec/)
-  spec.require_paths = ["lib"]
+  spec.files      = `git ls-files`.split($/)
+  spec.test_files = spec.files.grep(/^spec/)
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.3"
 end

data/lib/interactor.rb

@@ -1,54 +1,50 @@
 require "interactor/context"
+require "interactor/error"
+require "interactor/hooks"
 require "interactor/organizer"
 
 module Interactor
   def self.included(base)
     base.class_eval do
       extend ClassMethods
+      include Hooks
 
       attr_reader :context
     end
   end
 
   module ClassMethods
-    def perform(context = {})
-      new(context).tap do |instance|
-        instance.perform unless instance.failure?
-      end
+    def call(context = {})
+      new(context).tap(&:run).context
+    end
+
+    def call!(context = {})
+      new(context).tap(&:run!).context
     end
   end
 
   def initialize(context = {})
     @context = Context.build(context)
-    setup
-  end
-
-  def setup
   end
 
-  def perform
-  end
-
-  def rollback
+  def run
+    run!
+  rescue Failure
   end
 
-  def success?
-    context.success?
-  end
-
-  def failure?
-    context.failure?
-  end
-
-  def fail!(*args)
-    context.fail!(*args)
+  def run!
+    with_hooks do
+      call
+      context.called!(self)
+    end
+  rescue
+    context.rollback!
+    raise
   end
 
-  def method_missing(method, *)
-    context.fetch(method) { context.fetch(method.to_s) { super } }
+  def call
   end
 
-  def respond_to_missing?(method, *)
-    (context && (context.key?(method) || context.key?(method.to_s))) || super
+  def rollback
   end
 end

data/lib/interactor/context.rb

@@ -1,13 +1,9 @@
-require "delegate"
+require "ostruct"
 
 module Interactor
-  class Context < SimpleDelegator
+  class Context < OpenStruct
     def self.build(context = {})
-      self === context ? context : new(context.dup)
-    end
-
-    def initialize(context = {})
-      super(context)
+      self === context ? context : new(context)
     end
 
     def success?
@@ -19,8 +15,23 @@ module Interactor
     end
 
     def fail!(context = {})
-      update(context)
+      modifiable.update(context)
       @failure = true
+      raise Failure, self
+    end
+
+    def called!(interactor)
+      _called << interactor
+    end
+
+    def rollback!
+      return false if @rolled_back
+      _called.reverse_each(&:rollback)
+      @rolled_back = true
+    end
+
+    def _called
+      @called ||= []
     end
   end
 end

data/lib/interactor/error.rb

@@ -0,0 +1,10 @@
+module Interactor
+  class Failure < StandardError
+    attr_reader :context
+
+    def initialize(context = nil)
+      @context = context
+      super
+    end
+  end
+end

data/lib/interactor/hooks.rb

@@ -0,0 +1,53 @@
+module Interactor
+  module Hooks
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def before(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| before_hooks.push(hook) }
+      end
+
+      def after(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| after_hooks.unshift(hook) }
+      end
+
+      def before_hooks
+        @before_hooks ||= []
+      end
+
+      def after_hooks
+        @after_hooks ||= []
+      end
+    end
+
+    private
+
+    def with_hooks
+      run_before_hooks
+      yield
+      run_after_hooks
+    end
+
+    def run_before_hooks
+      run_hooks(self.class.before_hooks)
+    end
+
+    def run_after_hooks
+      run_hooks(self.class.after_hooks)
+    end
+
+    def run_hooks(hooks)
+      hooks.each { |hook| run_hook(hook) }
+    end
+
+    def run_hook(hook)
+      hook.is_a?(Symbol) ? send(hook) : instance_eval(&hook)
+    end
+  end
+end

data/lib/interactor/organizer.rb

@@ -10,41 +10,21 @@ module Interactor
     end
 
     module ClassMethods
-      def interactors
-        @interactors ||= []
+      def organize(*interactors)
+        @organized = interactors.flatten
       end
 
-      def organize(*interactors)
-        @interactors = interactors.flatten
+      def organized
+        @organized ||= []
       end
     end
 
     module InstanceMethods
-      def interactors
-        self.class.interactors
-      end
-
-      def perform
-        interactors.each do |interactor|
-          begin
-            instance = interactor.perform(context)
-          rescue
-            rollback
-            raise
-          end
-
-          rollback && break if failure?
-          performed << instance
+      def call
+        self.class.organized.each do |interactor|
+          interactor.call!(context)
         end
       end
-
-      def rollback
-        performed.reverse_each(&:rollback)
-      end
-
-      def performed
-        @performed ||= []
-      end
     end
   end
 end

data/spec/integration_spec.rb

@@ -0,0 +1,967 @@
+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
+      before do
+        context.steps << :before
+      end
+
+      after do
+        context.steps << :after
+      end
+    end
+  }
+
+  let(:organizer2) {
+    build_organizer(organize: [interactor2a, interactor2b, interactor2c]) do
+      before do
+        context.steps << :before2
+      end
+
+      after do
+        context.steps << :after2
+      end
+    end
+  }
+
+  let(:interactor2a) {
+    build_interactor do
+      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
+      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
+      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
+      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
+      before do
+        context.steps << :before4
+      end
+
+      after do
+        context.steps << :after4
+      end
+    end
+  }
+
+  let(:interactor4a) {
+    build_interactor do
+      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
+      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
+      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
+      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.build(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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :before4b, :call4b, :after4b,
+            :before4c, :call4c, :after4c,
+          :after4,
+          :before5, :call5, :after5,
+        :after
+      ])
+    end
+  end
+
+  context "when a before hook fails" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        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 a before hook errors" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        before do
+          raise "foo"
+          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 an after hook fails" do
+    let(:organizer) {
+      build_organizer(organize: [organizer2, interactor3, organizer4, interactor5]) do
+        before do
+          context.steps << :before
+        end
+
+        after do
+          context.fail!
+          context.steps << :after
+        end
+      end
+    }
+
+    it "rolls back successfully called interactors" do
+      expect {
+        organizer.call(context)
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :before4b, :call4b, :after4b,
+            :before4c, :call4c, :after4c,
+          :after4,
+          :before5, :call5, :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
+        before do
+          context.steps << :before
+        end
+
+        after do
+          raise "foo"
+          context.steps << :after
+        end
+      end
+    }
+
+    it "aborts" do
+      expect {
+        organizer.call(context) rescue nil
+      }.to change {
+        context.steps
+      }.from([]).to([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :before4b, :call4b, :after4b,
+            :before4c, :call4c, :after4c,
+          :after4,
+          :before5, :call5, :after5,
+        :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 before hook fails" do
+    let(:interactor3) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a nested before hook errors" do
+    let(:interactor3) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+        :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
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a nested call errors" do
+    let(:interactor3) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :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
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a nested after hook errors" do
+    let(:interactor3) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :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 deeply nested before hook fails" do
+    let(:interactor4b) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested before hook errors" do
+    let(:interactor4b) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :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 call fails" do
+    let(:interactor4b) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :before4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested call errors" do
+    let(:interactor4b) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :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
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :before4b, :call4b,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+  end
+
+  context "when a deeply nested after hook errors" do
+    let(:interactor4b) {
+      build_interactor do
+        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([
+        :before,
+          :before2,
+            :before2a, :call2a, :after2a,
+            :before2b, :call2b, :after2b,
+            :before2c, :call2c, :after2c,
+          :after2,
+          :before3, :call3, :after3,
+          :before4,
+            :before4a, :call4a, :after4a,
+            :before4b, :call4b,
+        :rollback4b,
+        :rollback4a,
+        :rollback3,
+        :rollback2c,
+        :rollback2b,
+        :rollback2a
+      ])
+    end
+
+    it "raises the error" do
+      expect {
+        organizer.call(context)
+      }.to raise_error("foo")
+    end
+  end
+end