rest_my_case 1.3.5 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: befb7a3cb43ce0e61ec02c2fc33afe9e1d9f734b
-  data.tar.gz: 18ac6c5fcf8ddb9a3d8534e7697fd1ae7995d299
+  metadata.gz: 4247a51223096c120fdb4055309c9fbbabd8517f
+  data.tar.gz: a3c6837847258f454c8cb604ceed36a1e836c1ef
 SHA512:
-  metadata.gz: 74deb7063872d6ce4f3a0ed098238b70c27f671f6611ccf291c8facfbe31d5f33f4b18fb368ec04de1b818453c514332422b4e4720fd06d20fa33f90ad6e6529
-  data.tar.gz: 57cce6814654046a2a9700952aff2dace3fceb10abb4d804d788facd9263bd9c17a294b802e255c6341e0426085c01efa47f55d21e015c54311de0c62d5357ad
+  metadata.gz: 6d7663942c2b7324ea877778295c87a19c7a18fdacb022e16136ca71b35d969b9beb473d8142a06bc9e9ef5b50540d93db4f3673232e2fd9c84700db8d6422a3
+  data.tar.gz: 1a39bb5b4b29d394c71179cba26052066e404d418026c3c150475cb6980a99803cb70503d5ff3542b3ea16346193db95bbb8978b51a8d31c0d9172694e007da4

data/console

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require(:default, 'development')
+
+
+require 'spec/support/perform'
+
+binding.pry

data/lib/rest_my_case.rb

@@ -1,16 +1,19 @@
 require 'ostruct'
 
-require "rest_my_case/config/shared"
+require "rest_my_case/version"
+require "rest_my_case/errors"
+
 require "rest_my_case/config/base"
 require "rest_my_case/config/general"
 
-require "rest_my_case/judge/base"
-require "rest_my_case/trial_case/base"
-require "rest_my_case/trial_case/context"
 require "rest_my_case/defense_attorney/base"
+require "rest_my_case/context/base"
+require "rest_my_case/judge/base"
+
+require "rest_my_case/trial/defendant"
+require "rest_my_case/trial/case"
+require "rest_my_case/trial/court"
 
-require "rest_my_case/version"
-require "rest_my_case/errors"
 require "rest_my_case/base"
 
 module RestMyCase

data/lib/rest_my_case/base.rb

@@ -4,24 +4,24 @@ module RestMyCase
 
     extend Config::Base
 
-    def self.depends(*use_cases)
-      dependencies.push *use_cases
+    TRIAL_COURT = Trial::Court.new Judge::Base, DefenseAttorney::Base
+
+    def self.depends(*use_case_classes)
+      dependencies.push *use_case_classes
     end
 
     def self.dependencies
       @dependencies ||= []
     end
 
-    def self.perform(attributes = {})
-      trial_case = TrialCase::Base.new self, attributes
-      attorney   = DefenseAttorney::Base.new trial_case
-      judge      = Judge::Base.new trial_case
-
-      attorney.build_case_for_the_defendant
+    def self.perform(attributes = nil)
+      attributes ||= {}
 
-      judge.execute_the_sentence
+      unless attributes.respond_to?(:to_hash)
+        raise ArgumentError.new('Must respond_to method #to_hash')
+      end
 
-      trial_case.context
+      TRIAL_COURT.execute([self], attributes.to_hash).context
     end
 
     def self.context_accessor(*methods)
@@ -39,13 +39,14 @@ module RestMyCase
       methods.each { |method| define_method(method) { context.send(method) } }
     end
 
-    ##################### INSTANCE METHODS BELLOW ###################
+    ######################## INSTANCE METHODS BELLOW ###########################
 
-    attr_reader :context, :options
+    attr_reader :context, :dependent_use_case, :options
 
-    def initialize(context, options = {})
-      @context = context
-      @options = options.dup
+    def initialize(context, dependent_use_case = nil)
+      @options            = {}
+      @context            = context
+      @dependent_use_case = dependent_use_case
     end
 
     def setup;  end
@@ -56,8 +57,18 @@ module RestMyCase
 
     def final; end
 
+    def invoke(*use_case_classes)
+      TRIAL_COURT.execute(use_case_classes, context.to_hash).context
+    end
+
+    def invoke!(*use_case_classes)
+      TRIAL_COURT.execute(use_case_classes, context).tap do |trial_case|
+        abort if trial_case.aborted
+      end.context
+    end
+
     def abort
-      options[:should_abort] = true
+      silent_abort? ? dependent_use_case.abort : (options[:should_abort] = true)
     end
 
     def abort!
@@ -80,6 +91,14 @@ module RestMyCase
       skip && raise(Errors::Skip)
     end
 
+    protected ######################## PROTECTED ###############################
+
+    def silent_abort?
+      return false if dependent_use_case.nil?
+
+      RestMyCase.get_config :silence_dependencies_abort, dependent_use_case.class
+    end
+
   end
 
 end

data/lib/rest_my_case/config/base.rb

@@ -3,8 +3,6 @@ module RestMyCase
 
     module Base
 
-      include Shared
-
       attr_accessor :silence_dependencies_abort
 
     end

data/lib/rest_my_case/config/general.rb

@@ -3,15 +3,14 @@ module RestMyCase
 
     class General
 
-      include Shared
+      include Base
 
       def initialize
-        @dependencies_first         = true
-        @parent_dependencies_first  = true
+        @silence_dependencies_abort = false
       end
 
-      def get(attribute, use_case)
-        custom_config = use_case.send(attribute)
+      def get(attribute, use_case_class)
+        custom_config = use_case_class.send(attribute)
 
         custom_config.nil? ? send(attribute) : custom_config
       end

data/lib/rest_my_case/{trial_case/context.rb → context/base.rb}

@@ -1,7 +1,15 @@
 module RestMyCase
-  module TrialCase
+  module Context
 
-    class Context < OpenStruct
+    class Base < OpenStruct
+
+      alias :attributes :marshal_dump
+
+      include ActiveModel::Serialization if defined?(ActiveModel)
+
+      def to_hash
+        Marshal.load Marshal.dump(attributes)
+      end
 
       def errors
         @errors ||= Hash.new { |hash, key| hash[key] = [] }
@@ -13,12 +21,6 @@ module RestMyCase
 
       alias :ok? :valid?
 
-      def serializable_hash(options = nil)
-        marshal_dump
-      end
-
-      alias :to_hash :serializable_hash
-
     end
 
   end

data/lib/rest_my_case/defense_attorney/base.rb

@@ -8,51 +8,35 @@ module RestMyCase
       end
 
       def build_case_for_the_defendant
-        @trial_case.use_cases = all_dependencies @trial_case.defendant
+        @trial_case.use_cases =
+          @trial_case.defendant.use_case_classes.map do |use_case_class|
+            all_dependencies(use_case_class)
+          end.flatten
       end
 
-      protected ###################### PROTECTED #########################
+      protected ######################## PROTECTED #############################
 
-      def all_dependencies(use_case, options = {})
-        return [] unless use_case.respond_to?(:dependencies)
+      def all_dependencies(use_case_class)
+        return [] unless use_case_class.respond_to? :dependencies
 
-        parent_dependencies = all_dependencies(use_case.superclass, options)
-
-        if RestMyCase.get_config(:parent_dependencies_first, use_case)
-          parent_dependencies | deep_dependencies(use_case, options)
-        else
-          deep_dependencies(use_case, options) | parent_dependencies
-        end
+        all_dependencies(use_case_class.superclass) |
+        dependencies_including_itself_last(use_case_class, nil)
       end
 
-      def deep_dependencies(use_case, options)
-        options           = build_options(use_case, options)
-        deep_dependencies = []
-
-        use_case.dependencies.each do |dependency|
-          deep_dependencies.push *all_dependencies(dependency, options)
-        end
-
-        include_current_use_case(deep_dependencies, use_case, options)
-      end
+      private ########################### PRIVATE ##############################
 
-      private ####################### PRIVATE ###########################
+      def dependencies_including_itself_last(use_case_class, dependent_use_case)
+        return [] unless use_case_class.superclass.respond_to? :dependencies
 
-      def build_options(use_case, options)
-        unless use_case.silence_dependencies_abort.nil?
-          options[:silent_abort] = use_case.silence_dependencies_abort
-        end
+        use_case = use_case_class.new(@trial_case.context, dependent_use_case)
 
-        options
+        dependencies(use_case).push use_case
       end
 
-      def include_current_use_case(dependencies, use_case, options)
-        return dependencies unless use_case.superclass.respond_to? :dependencies
-
-        append_method =
-          RestMyCase.get_config(:dependencies_first, use_case) ? :push : :unshift
-
-        dependencies.send append_method, use_case.new(@trial_case.context, options)
+      def dependencies(use_case)
+        use_case.class.dependencies.map do |dependency|
+          dependencies_including_itself_last dependency, use_case
+        end
       end
 
     end

data/lib/rest_my_case/judge/base.rb

@@ -9,14 +9,16 @@ module RestMyCase
         @use_case_that_aborted = false
       end
 
-      def execute_the_sentence
+      def determine_the_sentence
         run_setup_methods
         run_perform_methods
         run_rollback_methods
         run_final_methods
+
+        @trial_case.aborted = !!@use_case_that_aborted
       end
 
-      protected #################### PROTECTED ####################
+      protected ######################## PROTECTED #############################
 
       def run_setup_methods
         @trial_case.use_cases.each do |use_case|
@@ -36,15 +38,17 @@ module RestMyCase
         return nil unless @use_case_that_aborted
 
         @performed_use_cases.reverse.each do |use_case|
-          run_method(:rollback, use_case)
+          method_aborts?(:rollback, use_case)
         end
       end
 
       def run_final_methods
-        @trial_case.use_cases.each { |use_case| run_method(:final, use_case) }
+        @trial_case.use_cases.each do |use_case|
+          method_aborts?(:final, use_case)
+        end
       end
 
-      private #################### PRIVATE ######################
+      private ########################### PRIVATE ##############################
 
       def method_setup_has_aborted(use_case)
         method_aborts?(:setup, use_case)
@@ -60,20 +64,16 @@ module RestMyCase
 
       def method_aborts?(method_name, use_case)
         begin
-          run_method(method_name, use_case)
+          use_case.send(method_name)
 
           use_case.options[:should_abort] && @use_case_that_aborted = use_case
-        rescue Errors::Skip => exception
+        rescue Errors::Skip
           false
-        rescue Errors::Abort => exception
+        rescue Errors::Abort
           @use_case_that_aborted = use_case
         end
       end
 
-      def run_method(method_name, use_case)
-        use_case.send(method_name)
-      end
-
     end
 
   end

data/lib/rest_my_case/trial/case.rb

@@ -0,0 +1,28 @@
+module RestMyCase
+  module Trial
+
+    class Case
+
+      attr_accessor :use_cases, :aborted
+
+      attr_reader :context, :defendant
+
+      def initialize(use_case_classes, attributes)
+        @aborted   = false
+        @context   = build_context(attributes)
+        @defendant = Defendant.new use_case_classes
+        @use_cases = []
+      end
+
+      protected ######################## PROTECTED #############################
+
+      def build_context(attributes)
+        return attributes if attributes.is_a?(Context::Base)
+
+        Context::Base.new attributes
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/trial/court.rb

@@ -0,0 +1,19 @@
+module RestMyCase
+  module Trial
+
+    class Court < Struct.new(:judge_class, :defense_attorney_class)
+
+      def execute(use_case_classes, attributes = {})
+        trial_case = Case.new(use_case_classes, attributes)
+
+        defense_attorney_class.new(trial_case).build_case_for_the_defendant
+
+        judge_class.new(trial_case).determine_the_sentence
+
+        trial_case
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/trial/defendant.rb

@@ -0,0 +1,8 @@
+module RestMyCase
+  module Trial
+
+    class Defendant < Struct.new(:use_case_classes)
+    end
+
+  end
+end

data/lib/rest_my_case/version.rb

@@ -1,5 +1,5 @@
 module RestMyCase
 
-  VERSION = "1.3.5"
+  VERSION = "1.5.0"
 
 end

data/spec/rest_my_case/base_spec.rb

@@ -3,15 +3,18 @@ require 'spec_helper'
 describe RestMyCase::Base do
 
   describe ".dependencies" do
+
     it "should only list the class's dependencies" do
       expect(RestMyCaseBase::CreatePostWithComments.dependencies).to \
         eq [RestMyCaseBase::BuildComments, RestMyCaseBase::CreateComments]
     end
+
   end
 
   describe ".context_accessor" do
-    let(:context) { RestMyCase::TrialCase::Context.new(id: 1, comment: 'my comment', session: -1) }
-    let(:use_case)   { RestMyCaseBase::CreatePostWithComments.new(context) }
+
+    let(:context)  { RestMyCase::Context::Base.new(id: 1, comment: 'my comment', session: -1) }
+    let(:use_case) { RestMyCaseBase::CreatePostWithComments.new(context) }
 
     it "Should create getters targeting to context" do
       expect(use_case.respond_to?(:comment)).to be true
@@ -29,11 +32,13 @@ describe RestMyCase::Base do
       use_case.comment = 'your comment'
       expect(use_case.context.comment).to eq 'your comment'
     end
+
   end
 
   describe ".context_writer" do
-    let(:context) { RestMyCase::TrialCase::Context.new }
-    let(:use_case)   { RestMyCaseBase::CreatePostWithComments.new(context) }
+
+    let(:context)  { RestMyCase::Context::Base.new }
+    let(:use_case) { RestMyCaseBase::CreatePostWithComments.new(context) }
 
     it "Should create setters targeting to context" do
       expect(use_case.respond_to?(:id)).to be false
@@ -45,11 +50,13 @@ describe RestMyCase::Base do
 
       expect(use_case.context.id).to eq 2
     end
+
   end
 
   describe ".context_reader" do
-    let(:context) { RestMyCase::TrialCase::Context.new(id: 1, comment: 'my comment', session: -1) }
-    let(:use_case)   { RestMyCaseBase::CreatePostWithComments.new(context) }
+
+    let(:context)  { RestMyCase::Context::Base.new(id: 1, comment: 'my comment', session: -1) }
+    let(:use_case) { RestMyCaseBase::CreatePostWithComments.new(context) }
 
     it "Should create getters targeting to context" do
       expect(use_case.respond_to?(:session)).to be true
@@ -59,26 +66,40 @@ describe RestMyCase::Base do
     it "Getter should delegate to context" do
       expect(use_case.session).to eq -1
     end
+
   end
 
   describe ".perform" do
 
-    context "When a use case #fail during the setup process" do
-      before do
-        class Perform::ValidateName < RestMyCase::Base
-          def setup
-            fail('no name!')
-            context.setup << self.class.name
-          end
-        end
+    context "When something that doesn't responds to #to_hash is passed down" do
 
-        @context = Perform::CreatePost.perform
+      it "should raise an exception" do
+        expect { Perform::CreatePost.perform(Object.new) }.to \
+          raise_error(ArgumentError)
       end
 
-      after do
-        class Perform::ValidateName < RestMyCase::Base
-          def setup; context.setup << self.class.name; end
-        end
+    end
+
+    context "When nil is passed down" do
+
+      it "should NOT raise an exception" do
+        expect { Perform::CreatePost.perform(nil) }.not_to raise_error
+      end
+
+    end
+
+    context "When nothing is passed down" do
+
+      it "should NOT raise an exception" do
+        expect { Perform::CreatePost.perform }.not_to raise_error
+      end
+
+    end
+
+    context "When a use case calls #fail during the setup process" do
+      before do
+        @context = Perform::CreatePost.perform \
+          fail: ['Perform::ValidateName_setup', 'Perform::ValidateBody_setup']
       end
 
       it "context should reflect an invalid state" do
@@ -90,29 +111,17 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 2
+        expect(@context.setup.length).to be 3
         expect(@context.perform.length).to be 0
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 6
+        expect(@context.final.length).to be 7
       end
     end
 
-    context "When a use case #fail! during the setup process" do
+    context "When a use case calls #fail! during the setup process" do
       before do
-        class Perform::ValidateName < RestMyCase::Base
-          def setup
-            fail!('no name!')
-            context.setup << self.class.name
-          end
-        end
-
-        @context = Perform::CreatePost.perform
-      end
-
-      after do
-        class Perform::ValidateName < RestMyCase::Base
-          def setup; context.setup << self.class.name; end
-        end
+        @context = Perform::CreatePost.perform \
+          fail_bang: ['Perform::ValidateName_setup']
       end
 
       it "context should reflect an invalid state" do
@@ -124,29 +133,72 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 1
+        expect(@context.setup.length).to be 2
         expect(@context.perform.length).to be 0
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 6
+        expect(@context.final.length).to be 7
       end
     end
 
-    context "When a use case #skip during the setup process" do
+    context "When a use case calls #abort! during the setup process" do
       before do
-        class Perform::ValidateBody < RestMyCase::Base
-          def setup
-            skip
-            context.setup << self.class.name
-          end
-        end
+        @context = Perform::CreatePost.perform \
+          abort_bang: ['Perform::ValidateName_setup']
+      end
 
-        @context = Perform::CreatePost.perform
+      it "context should reflect an valid state" do
+        expect(@context.valid?).to be true
       end
 
-      after do
-        class Perform::ValidateName < RestMyCase::Base
-          def setup; context.setup << self.class.name; end
-        end
+      it "context prove that only the correct method have ran" do
+        expect(@context.setup.length).to be 2
+        expect(@context.perform.length).to be 0
+        expect(@context.rollback.length).to be 0
+        expect(@context.final.length).to be 7
+      end
+    end
+
+    context "When a use case calls #abort! during the perform process" do
+      before do
+        @context = Perform::CreatePost.perform \
+          abort_bang: ['Perform::ValidateName_perform']
+      end
+
+      it "context should reflect an valid state" do
+        expect(@context.valid?).to be true
+      end
+
+      it "context prove that only the correct method have ran" do
+        expect(@context.setup.length).to be 7
+        expect(@context.perform.length).to be 2
+        expect(@context.rollback.length).to be 3
+        expect(@context.final.length).to be 7
+      end
+    end
+
+    context "When a use case calls #skip during the setup process" do
+      before do
+        @context = Perform::CreatePost.perform \
+          skip: ['Perform::ValidateBody_setup']
+      end
+
+      it "context should reflect an valid state" do
+        expect(@context.valid?).to be true
+      end
+
+      it "context prove that only the correct method have ran" do
+        expect(@context.setup.length).to be 7
+        expect(@context.perform.length).to be 6
+        expect(@context.rollback.length).to be 0
+        expect(@context.final.length).to be 7
+      end
+    end
+
+    context "When a use case calls #skip! during the setup process" do
+
+      before do
+        @context = Perform::CreatePost.perform \
+          skip_bang: ['Perform::ValidateBody_setup']
       end
 
       it "context should reflect an valid state" do
@@ -155,10 +207,237 @@ describe RestMyCase::Base do
 
       it "context prove that only the correct method have ran" do
         expect(@context.setup.length).to be 6
-        expect(@context.perform.length).to be 5
+        expect(@context.perform.length).to be 6
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 6
+        expect(@context.final.length).to be 7
+      end
+
+    end
+
+    context "When dependent use_case has silence_dependencies_abort = true" do
+
+      before  { Perform::Validations.silence_dependencies_abort = true }
+      after   { Perform::Validations.silence_dependencies_abort = nil }
+
+      context "When a use case calls #fail during the setup process" do
+        before do
+          @context = Perform::CreatePost.perform \
+            fail: ['Perform::ValidateName_setup', 'Perform::ValidateBody_setup']
+        end
+
+        it "context should reflect an invalid state" do
+          expect(@context.valid?).to be false
+        end
+
+        it "context should contain only 2 errors" do
+          expect(@context.errors.keys.length).to be 2
+        end
+
+        it "context prove that only the correct method have ran" do
+          expect(@context.setup.length).to be 5
+          expect(@context.perform.length).to be 0
+          expect(@context.rollback.length).to be 0
+          expect(@context.final.length).to be 7
+        end
+
       end
+
+      context "When a use case calls #fail during the perform process" do
+
+        before do
+          @context = Perform::CreatePost.perform \
+            fail: ['Perform::ValidateName_perform', 'Perform::ValidateBody_perform']
+        end
+
+        it "context should reflect an invalid state" do
+          expect(@context.valid?).to be false
+        end
+
+        it "context should contain only 2 errors" do
+          expect(@context.errors.keys.length).to be 2
+        end
+
+        it "context prove that only the correct method have ran" do
+          expect(@context.setup.length).to be 7
+          expect(@context.perform.length).to be 5
+          expect(@context.rollback.length).to be 5
+          expect(@context.final.length).to be 7
+        end
+
+      end
+
+    end
+
+    context "When general config has silence_dependencies_abort = true" do
+
+      before do
+        RestMyCase.configure do |config|
+          config.silence_dependencies_abort = true
+        end
+      end
+      after { RestMyCase.reset_config }
+
+      context "When a use case calls #fail during the perform process" do
+
+        before do
+          @context = Perform::CreatePost.perform \
+            fail: ['Perform::ValidateName_perform', 'Perform::ValidateBody_perform', 'Perform::BuildPost_perform', 'Perform::SavePost_perform']
+        end
+
+        it "context should reflect an invalid state" do
+          expect(@context.valid?).to be false
+        end
+
+        it "context should contain only 4 errors" do
+          expect(@context.errors.keys.length).to be 4
+        end
+
+        it "context prove that only the correct method have ran" do
+          expect(@context.setup.length).to be 7
+          expect(@context.perform.length).to be 7
+          expect(@context.rollback.length).to be 7
+          expect(@context.final.length).to be 7
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#invoke" do
+
+    class Perform::Invoker < Perform::UseCaseWrapper
+      def perform
+        super
+        invoke Perform::BuildPost, Perform::Validations, Perform::SavePost
+      end
+    end
+
+    it "should invoke other use cases with the invoker's cloned context and they can't alter the invoker's context" do
+      context = Perform::Invoker.perform
+
+      expect(context.setup.length).to be 2
+      expect(context.perform.length).to be 2
+      expect(context.rollback.length).to be 0
+      expect(context.final.length).to be 2
+    end
+
+  end
+
+  describe "#invoke!" do
+
+    context "when the invokees don't abort" do
+
+      class Perform::ScreammingInvoker < Perform::UseCaseWrapper
+        def perform
+          super
+          invoke! Perform::BuildPost, Perform::Validations, Perform::SavePost
+        end
+      end
+
+      it "should invoke other use cases with the invoker's context and actually alter it" do
+        @context = Perform::ScreammingInvoker.perform
+
+        expect(@context.setup).to eq [
+          "Perform::UseCaseWrapper",
+          "Perform::ScreammingInvoker",
+          "Perform::UseCaseWrapper",
+          "Perform::BuildPost",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateName",
+          "Perform::ValidateBody",
+          "Perform::Validations",
+          "Perform::UseCaseWrapper",
+          "Perform::SavePost"
+        ]
+        expect(@context.perform).to eq [
+          "Perform::UseCaseWrapper",
+          "Perform::ScreammingInvoker",
+          "Perform::UseCaseWrapper",
+          "Perform::BuildPost",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateName",
+          "Perform::ValidateBody",
+          "Perform::Validations",
+          "Perform::UseCaseWrapper",
+          "Perform::SavePost"
+        ]
+        expect(@context.rollback).to eq []
+        expect(@context.final).to eq [
+          "Perform::UseCaseWrapper",
+          "Perform::BuildPost",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateName",
+          "Perform::ValidateBody",
+          "Perform::Validations",
+          "Perform::UseCaseWrapper",
+          "Perform::SavePost",
+          "Perform::UseCaseWrapper",
+          "Perform::ScreammingInvoker"
+        ]
+      end
+
+    end
+
+    context "when the invokees abort" do
+
+      class Perform::Validations2 < Perform::UseCaseWrapper
+        def perform
+          super
+
+          invoke! Perform::ValidateName, Perform::ValidateBody
+        end
+      end
+
+      class Perform::CreatePost2 < Perform::UseCaseWrapper
+        depends Perform::BuildPost, Perform::Validations2, Perform::SavePost
+      end
+
+      before do
+        @context = Perform::CreatePost2.perform \
+          fail: ['Perform::ValidateName_perform', 'Perform::ValidateBody_perform']
+      end
+
+      it "invoker should abort the process it his invokees have also aborted" do
+        expect(@context.setup).to eq [
+          "Perform::UseCaseWrapper",
+          "Perform::BuildPost",
+          "Perform::Validations2",
+          "Perform::SavePost",
+          "Perform::CreatePost2",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateName",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateBody"
+        ]
+        expect(@context.perform).to eq [
+          "Perform::UseCaseWrapper",
+          "Perform::BuildPost",
+          "Perform::Validations2",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateName"
+        ]
+        expect(@context.rollback).to eq [
+          "Perform::ValidateName",
+          "Perform::UseCaseWrapper",
+          "Perform::Validations2",
+          "Perform::BuildPost",
+          "Perform::UseCaseWrapper"
+        ]
+        expect(@context.final).to eq [
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateName",
+          "Perform::UseCaseWrapper",
+          "Perform::ValidateBody",
+          "Perform::UseCaseWrapper",
+          "Perform::BuildPost",
+          "Perform::Validations2",
+          "Perform::SavePost",
+          "Perform::CreatePost2"
+        ]
+      end
+
     end
 
   end