activeinteractor 1.0.1 → 1.1.0

data/lib/active_interactor/organizer/interactor_interface.rb

@@ -14,6 +14,13 @@ module ActiveInteractor
     #
     #  @return [Hash{Symbol=>Proc, Symbol}] conditional options for the {ActiveInteractor::Base interactor} class
     #
+    # @!attribute [r] callbacks
+    #   Callbacks for the interactor_class
+    #
+    #   @since 1.1.0
+    #
+    #   @return [Hash{Symbol=>*}] the interactor callbacks
+    #
     # @!attribute [r] interactor_class
     #  An {ActiveInteractor::Base interactor} class
     #
@@ -27,11 +34,12 @@ module ActiveInteractor
     #  @return [Hash{Symbol=>*}] {Interactor::Perform::Options} for the {ActiveInteractor::Base interactor}
     #   {Interactor::Perform#perform #perform}
     class InteractorInterface
-      attr_reader :filters, :interactor_class, :perform_options
+      attr_reader :filters, :callbacks, :interactor_class, :perform_options
 
       # Keywords for conditional filters
       # @return [Array<Symbol>]
       CONDITIONAL_FILTERS = %i[if unless].freeze
+      CALLBACKS = %i[before after].freeze
 
       # Initialize a new instance of {InteractorInterface}
       #
@@ -40,9 +48,10 @@ module ActiveInteractor
       #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
       # @return [InteractorInterface] a new instance of {InteractorInterface}
       def initialize(interactor_class, options = {})
-        @interactor_class = interactor_class.to_s.classify.safe_constantize
+        @interactor_class = interactor_class.to_s.camelize.safe_constantize
         @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
-        @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) }
+        @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
+        @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
       end
 
       # Call the {#interactor_class} {Interactor::Perform::ClassMethods#perform .perform} or
@@ -57,21 +66,29 @@ module ActiveInteractor
       #  {Context::Status#fail! fails} its {Context::Base context}.
       # @return [Class] an instance of {Context::Base context}
       def perform(target, context, fail_on_error = false, perform_options = {})
-        return if check_conditionals(target, filters[:if]) == false
-        return if check_conditionals(target, filters[:unless]) == true
+        return if check_conditionals(target, :if) == false
+        return if check_conditionals(target, :unless) == true
 
         method = fail_on_error ? :perform! : :perform
         options = self.perform_options.merge(perform_options)
         interactor_class.send(method, context, options)
       end
 
+      def execute_inplace_callback(target, callback)
+        resolve_option(target, callbacks[callback])
+      end
+
       private
 
       def check_conditionals(target, filter)
-        return unless filter
+        resolve_option(target, filters[filter])
+      end
+
+      def resolve_option(target, opt)
+        return unless opt
 
-        return target.send(filter) if filter.is_a?(Symbol)
-        return target.instance_exec(&filter) if filter.is_a?(Proc)
+        return target.send(opt) if opt.is_a?(Symbol)
+        return target.instance_exec(&opt) if opt.is_a?(Proc)
       end
     end
   end

data/lib/active_interactor/organizer/interactor_interface_collection.rb

@@ -14,6 +14,7 @@ module ActiveInteractor
     #  @return [Array<InteractorInterface>] the {InteractorInterface} collection
     class InteractorInterfaceCollection
       attr_reader :collection
+
       # @!method map(&block)
       #  Invokes the given block once for each element of {#collection}.
       #  @return [Array] a new array containing the values returned by the block.

data/lib/active_interactor/organizer/perform.rb

@@ -73,10 +73,19 @@ module ActiveInteractor
         context_fail! if contexts.any?(&:failure?)
       end
 
+      def execute_and_merge_contexts(interface)
+        interface.execute_inplace_callback(self, :before)
+        result = execute_interactor_with_callbacks(interface, true)
+        return if result.nil?
+
+        context.merge!(result)
+        context_fail! if result.failure?
+        interface.execute_inplace_callback(self, :after)
+      end
+
       def perform_in_order
         self.class.organized.each do |interface|
-          result = execute_interactor_with_callbacks(interface, true)
-          context.merge!(result) if result
+          execute_and_merge_contexts(interface)
         end
       rescue ActiveInteractor::Error::ContextFailure => e
         context.merge!(e.context)

data/lib/active_interactor/rails/orm/dynamoid.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'dynamoid/document'
+
+Dynamoid::Document::ClassMethods.include ActiveInteractor::Models

data/lib/active_interactor/rails/orm/mongoid.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+ActiveSupport.on_load(:mongoid) do
+  Mongoid::Document::ClassMethods.include ActiveInteractor::Models
+end

data/lib/active_interactor/version.rb

@@ -3,5 +3,5 @@
 module ActiveInteractor
   # The ActiveInteractor version
   # @return [String] the ActiveInteractor version
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/lib/rails/generators/templates/organizer.erb

@@ -6,8 +6,8 @@ class <%= class_name %> < ApplicationOrganizer
 
 <%- end -%>
 <%- if interactors.any? -%>
-  organize <%= interactors.map(&:classify).join(", ") %>
+  organize <%= interactors.join(", ") %>
 <%- else -%>
-  # organize Interactor1, Interactor2
+  # organize :interactor_1, :interactor_2
 <%- end -%>
 end

data/spec/active_interactor/base_spec.rb

@@ -27,6 +27,17 @@ RSpec.describe ActiveInteractor::Base do
           subject
           expect(described_class.context_class).to eq TestContext
         end
+
+        # https://github.com/aaronmallen/activeinteractor/issues/168
+        context 'when singularized' do
+          let!(:singularized_class) { build_context('PlaceData') }
+          let(:klass) { 'PlaceData' }
+
+          it 'is expected to assign the appropriate context class' do
+            subject
+            expect(described_class.context_class).to eq PlaceData
+          end
+        end
       end
 
       context 'when passed as a symbol' do
@@ -36,6 +47,17 @@ RSpec.describe ActiveInteractor::Base do
           subject
           expect(described_class.context_class).to eq TestContext
         end
+
+        # https://github.com/aaronmallen/activeinteractor/issues/168
+        context 'when singularized' do
+          let!(:singularized_class) { build_context('PlaceData') }
+          let(:klass) { :place_data }
+
+          it 'is expected to assign the appropriate context class' do
+            subject
+            expect(described_class.context_class).to eq PlaceData
+          end
+        end
       end
 
       context 'when passed as a constant' do
@@ -45,6 +67,17 @@ RSpec.describe ActiveInteractor::Base do
           subject
           expect(described_class.context_class).to eq TestContext
         end
+
+        # https://github.com/aaronmallen/activeinteractor/issues/168
+        context 'when singularized' do
+          let!(:singularized_class) { build_context('PlaceData') }
+          let(:klass) { PlaceData }
+
+          it 'is expected to assign the appropriate context class' do
+            subject
+            expect(described_class.context_class).to eq PlaceData
+          end
+        end
       end
     end
   end

data/spec/active_interactor/context/base_spec.rb

@@ -34,6 +34,49 @@ RSpec.describe ActiveInteractor::Context::Base do
     end
   end
 
+  describe '#[]' do
+    subject { instance[attribute] }
+
+    context 'with class attributes []' do
+      let(:instance) { build_context.new }
+
+      context 'with attribute nil' do
+        let(:attribute) { :foo }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'with attribute equal to "foo"' do
+        let(:attribute) { :foo }
+        before { instance.foo = 'foo' }
+
+        it { is_expected.to eq 'foo' }
+      end
+    end
+
+    context 'with class attributes [:foo]' do
+      let!(:context_class) do
+        build_context do
+          attributes :foo
+        end
+      end
+      let(:instance) { context_class.new }
+
+      context 'with attribute nil' do
+        let(:attribute) { :foo }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'with attribute equal to "foo"' do
+        let(:attribute) { :foo }
+        before { instance.foo = 'foo' }
+
+        it { is_expected.to eq 'foo' }
+      end
+    end
+  end
+
   describe '#attribute?' do
     subject { instance.attribute?(attribute) }
 
@@ -127,7 +170,7 @@ RSpec.describe ActiveInteractor::Context::Base do
       it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
 
       it 'is expected not to merge errors' do
-        expect(instance.errors).not_to receive(:merge!)
+        expect(instance.errors).not_to receive(:merge!).with(nil)
         subject
       rescue ActiveInteractor::Error::ContextFailure # rubocop:disable Lint/SuppressedException
       end

data/spec/active_interactor/organizer/interactor_interface_spec.rb

@@ -84,6 +84,72 @@ RSpec.describe ActiveInteractor::Organizer::InteractorInterface do
         end
       end
 
+      context 'with options {:before => :some_method }' do
+        let(:options) { { before: :some_method } }
+
+        describe '#callbacks' do
+          subject { instance.callbacks }
+
+          it { is_expected.to eq(before: :some_method) }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
+      context 'with options {:before => -> { context.test = true } }' do
+        let(:options) { { before: -> { context.test = true } } }
+
+        describe '#callbacks' do
+          subject { instance.callbacks }
+
+          it { expect(subject[:before]).not_to be_nil }
+          it { expect(subject[:before]).to be_a Proc }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
+      context 'with options {:after => :some_method }' do
+        let(:options) { { after: :some_method } }
+
+        describe '#callbacks' do
+          subject { instance.callbacks }
+
+          it { is_expected.to eq(after: :some_method) }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
+      context 'with options {:after => -> { context.test = true } }' do
+        let(:options) { { after: -> { context.test = true } } }
+
+        describe '#callbacks' do
+          subject { instance.callbacks }
+
+          it { expect(subject[:after]).not_to be_nil }
+          it { expect(subject[:after]).to be_a Proc }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
       context 'with options { :validate => false }' do
         let(:options) { { validate: false } }
 
@@ -100,8 +166,8 @@ RSpec.describe ActiveInteractor::Organizer::InteractorInterface do
         end
       end
 
-      context 'with options { :if => :some_method, :validate => false }' do
-        let(:options) { { if: :some_method, validate: false } }
+      context 'with options { :if => :some_method, :validate => false, :before => :other_method }' do
+        let(:options) { { if: :some_method, validate: false, before: :other_method } }
 
         describe '#filters' do
           subject { instance.filters }
@@ -109,6 +175,12 @@ RSpec.describe ActiveInteractor::Organizer::InteractorInterface do
           it { is_expected.to eq(if: :some_method) }
         end
 
+        describe '#callbacks' do
+          subject { instance.callbacks }
+
+          it { is_expected.to eq(before: :other_method) }
+        end
+
         describe '#perform_options' do
           subject { instance.perform_options }
 

data/spec/integration/a_basic_organizer_spec.rb

@@ -69,6 +69,26 @@ RSpec.describe 'A basic organizer', type: :integration do
         expect_any_instance_of(test_interactor_2).not_to receive(:perform!)
         subject
       end
+
+      # https://github.com/aaronmallen/activeinteractor/issues/169
+      context 'with error message "something went wrong"' do
+        let!(:test_interactor_1) do
+          build_interactor('TestInteractor1') do
+            def perform
+              context.fail!('something went wrong')
+            end
+          end
+        end
+
+        it { expect { subject }.not_to raise_error }
+        it { is_expected.to be_a interactor_class.context_class }
+        it { is_expected.to be_failure }
+        it { expect(subject.errors.count).to eq 1 }
+        it 'is expected to have errors "something went wrong" on :context' do
+          expect(subject.errors[:context]).not_to be_empty
+          expect(subject.errors[:context]).to include 'something went wrong'
+        end
+      end
     end
   end
 
@@ -92,6 +112,26 @@ RSpec.describe 'A basic organizer', type: :integration do
         expect_any_instance_of(test_interactor_1).to receive(:rollback)
         subject
       end
+
+      # https://github.com/aaronmallen/activeinteractor/issues/169
+      context 'with error message "something went wrong"' do
+        let!(:test_interactor_2) do
+          build_interactor('TestInteractor2') do
+            def perform
+              context.fail!('something went wrong')
+            end
+          end
+        end
+
+        it { expect { subject }.not_to raise_error }
+        it { is_expected.to be_a interactor_class.context_class }
+        it { is_expected.to be_failure }
+        it { expect(subject.errors.count).to eq 1 }
+        it 'is expected to have errors "something went wrong" on :context' do
+          expect(subject.errors[:context]).not_to be_empty
+          expect(subject.errors[:context]).to include 'something went wrong'
+        end
+      end
     end
   end
 
@@ -100,6 +140,8 @@ RSpec.describe 'A basic organizer', type: :integration do
     let!(:test_context_class) do
       build_context('TestInteractor1Context') do
         attributes :foo
+        attributes :baz
+        attributes :zoo
       end
     end
 
@@ -111,6 +153,12 @@ RSpec.describe 'A basic organizer', type: :integration do
           context.has_foo_as_element = context[:foo].present?
           context.has_bar_as_method = context.bar.present?
           context.has_bar_as_element = context[:bar].present?
+          context.baz = 'baz'
+          context.has_baz_as_method = context.baz.present?
+          context.has_baz_as_element = context[:baz].present?
+          context[:zoo] = 'zoo'
+          context.has_zoo_as_method = context.zoo.present?
+          context.has_zoo_as_element = context[:zoo].present?
         end
       end
     end
@@ -127,13 +175,17 @@ RSpec.describe 'A basic organizer', type: :integration do
 
       describe '.perform' do
         subject(:result) { interactor_class.perform(context_attributes) }
-        it { is_expected.to have_attributes(foo: 'foo', bar: 'bar') }
+        it { is_expected.to have_attributes(foo: 'foo', bar: 'bar', baz: 'baz', zoo: 'zoo') }
 
         it 'is expected to copy all attributes in the contexts to each interactor' do
           expect(subject.has_foo_as_method).to be true
           expect(subject.has_foo_as_element).to be true
           expect(subject.has_bar_as_method).to be true
           expect(subject.has_bar_as_element).to be true
+          expect(subject.has_baz_as_method).to be true
+          expect(subject.has_baz_as_element).to be true
+          expect(subject.has_zoo_as_method).to be true
+          expect(subject.has_zoo_as_element).to be true
         end
 
         describe '#attributes' do

data/spec/integration/active_record_integration_spec.rb

@@ -6,356 +6,22 @@ begin
   require 'active_interactor/rails/orm/active_record'
 
   RSpec.describe 'ActiveRecord integration', type: :integration do
-    let!(:active_record_base_mock) do
-      build_class('ActiveRecordBaseMock') do
-        def self.attr_accessor(*attributes)
-          attribute_keys.concat(attributes.map(&:to_sym))
-          super
-        end
-
-        def self.attribute_keys
-          @attribute_keys ||= []
-        end
-
-        def initialize(attributes = nil, _options = {})
-          (attributes || {}).each do |key, value|
-            instance_variable_set("@#{key}", value)
-          end
-        end
-
-        def [](name)
-          instance_variable_get("@#{name}")
-        end
-
-        def []=(name, value)
-          instance_variable_set("@#{name}", value)
-        end
-
-        def attributes
-          self.class.attribute_keys.each_with_object({}) do |key, hash|
-            hash[key] = instance_variable_get("@#{key}")
-          end
-        end
-
-        def to_h
-          attributes.to_h
-        end
-      end
-    end
+    let!(:active_record_base_mock) { build_class('ActiveRecordBaseMock') }
 
     context 'after ActiveSupport.run_load_hooks has been received with :active_record' do
       before { ActiveSupport.run_load_hooks(:active_record, active_record_base_mock) }
 
-      describe 'an ActiveRecord model class with .acts_as_context' do
-        let(:model_mock) do
-          build_class('ModelMock', active_record_base_mock) do
-            attr_accessor :foo
+      describe 'an ActiveRecord model class with .acts_as_context and attribute :foo' do
+        let(:model_class) do
+          build_class('ModelClass', active_record_base_mock) do
+            include ActiveModel::Attributes
+            include ActiveModel::Model
             acts_as_context
+            attribute :foo
           end
         end
 
-        describe 'as an instance' do
-          subject { model_mock.new }
-
-          it { is_expected.to respond_to :called! }
-          it { is_expected.to respond_to :fail! }
-          it { is_expected.to respond_to :fail? }
-          it { is_expected.to respond_to :failure? }
-          it { is_expected.to respond_to :merge! }
-          it { is_expected.to respond_to :rollback! }
-          it { is_expected.to respond_to :success? }
-          it { is_expected.to respond_to :successful? }
-        end
-
-        describe '.new' do
-          subject { model_mock.new(attributes) }
-          let(:attributes) { nil }
-
-          it 'is expected not to receive #copy_flags!' do
-            expect_any_instance_of(model_mock).not_to receive(:copy_flags!)
-            subject
-          end
-
-          it 'is expected not to receive #copy_called!' do
-            expect_any_instance_of(model_mock).not_to receive(:copy_called!)
-            subject
-          end
-
-          it 'is expected to receive super on parent class with nil attributes' do
-            expect(active_record_base_mock).to receive(:new).with(nil)
-            subject
-          end
-
-          context 'with attributes { :foo => "foo" }' do
-            let(:attributes) { { foo: 'foo' } }
-
-            it { expect { subject }.not_to raise_error }
-
-            it 'is expected to receive #copy_flags!' do
-              expect_any_instance_of(model_mock).to receive(:copy_flags!).with(foo: 'foo')
-              subject
-            end
-
-            it 'is expected to receive #copy_called!' do
-              expect_any_instance_of(model_mock).to receive(:copy_called!).with(foo: 'foo')
-              subject
-            end
-
-            it 'is expected to receive super on parent class with { :foo => "foo" }' do
-              expect(active_record_base_mock).to receive(:new).with(foo: 'foo')
-              subject
-            end
-          end
-
-          context 'with attributes being an instance of ModelMock having attributes { :foo => "foo" }' do
-            let(:previous_instance) { model_mock.new(foo: 'foo') }
-            let(:attributes) { previous_instance }
-
-            it { is_expected.to have_attributes(foo: 'foo') }
-
-            context 'with _failed equal to true on previous instance' do
-              before { previous_instance.instance_variable_set('@_failed', true) }
-
-              it { is_expected.to be_failure }
-            end
-
-            context 'with _rolled_back equal to true on previous instance' do
-              before { previous_instance.instance_variable_set('@_rolled_back', true) }
-
-              it 'is expected to have instance variable @_rolled_back eq to true' do
-                expect(subject.instance_variable_get('@_rolled_back')).to eq true
-              end
-            end
-
-            context 'with _called eq to ["foo"] on previous instance' do
-              before { previous_instance.instance_variable_set('@_called', %w[foo]) }
-
-              it 'is expected to have instance variable @_called eq to ["foo"]' do
-                expect(subject.instance_variable_get('@_called')).to eq %w[foo]
-              end
-            end
-          end
-        end
-
-        describe '#merge!' do
-          subject { model_mock.new(attributes).merge!(merge_instance) }
-          context 'having attributes { :foo => nil }' do
-            let(:attributes) { { foo: nil } }
-
-            context 'with merging instance having attributes { :foo => "foo" }' do
-              let(:merge_instance) { model_mock.new(foo: 'foo') }
-
-              it { is_expected.to have_attributes(foo: 'foo') }
-
-              context 'with _failed equal to true on merging instance' do
-                before { merge_instance.instance_variable_set('@_failed', true) }
-
-                it { is_expected.to be_failure }
-              end
-
-              context 'with _rolled_back equal to true on merging instance' do
-                before { merge_instance.instance_variable_set('@_rolled_back', true) }
-
-                it 'is expected to have instance variable @_rolled_back eq to true' do
-                  expect(subject.instance_variable_get('@_rolled_back')).to eq true
-                end
-              end
-            end
-          end
-
-          context 'having attributes { :foo => "foo"}' do
-            let(:attributes) { { foo: 'foo' } }
-
-            context 'with merging instance having attributes { :foo => "bar" }' do
-              let(:merge_instance) { model_mock.new(foo: 'bar') }
-
-              it { is_expected.to have_attributes(foo: 'bar') }
-
-              context 'with _failed equal to true on merging instance' do
-                before { merge_instance.instance_variable_set('@_failed', true) }
-
-                it { is_expected.to be_failure }
-              end
-
-              context 'with _rolled_back equal to true on merging instance' do
-                before { merge_instance.instance_variable_set('@_rolled_back', true) }
-
-                it 'is expected to have instance variable @_rolled_back eq to true' do
-                  expect(subject.instance_variable_get('@_rolled_back')).to eq true
-                end
-              end
-            end
-          end
-        end
-      end
-
-      describe 'a basic interactor using an ActiveRecord model class as context' do
-        let!(:model_mock) do
-          require 'active_model'
-          build_class('ModelMock', active_record_base_mock) do
-            include ActiveModel::Validations
-            attr_accessor :foo
-            acts_as_context
-          end
-        end
-
-        let(:interactor_class) do
-          build_interactor do
-            contextualize_with :model_mock
-
-            def perform
-              context.foo = 'foo'
-            end
-          end
-        end
-
-        include_examples 'a class with interactor methods'
-        include_examples 'a class with interactor callback methods'
-        include_examples 'a class with interactor context methods'
-
-        describe '.context_class' do
-          subject { interactor_class.context_class }
-
-          it { is_expected.to eq model_mock }
-        end
-
-        describe '.perform' do
-          subject { interactor_class.perform }
-
-          it { is_expected.to be_a model_mock }
-          it { is_expected.to be_successful }
-          it { is_expected.to have_attributes(foo: 'foo') }
-        end
-
-        describe '.perform!' do
-          subject { interactor_class.perform! }
-
-          it { expect { subject }.not_to raise_error }
-          it { is_expected.to be_a model_mock }
-          it { is_expected.to be_successful }
-          it { is_expected.to have_attributes(foo: 'foo') }
-        end
-
-        context 'failing the context on #perform' do
-          let(:interactor_class) do
-            build_interactor do
-              contextualize_with :model_mock
-
-              def perform
-                context.fail!
-              end
-            end
-          end
-
-          describe '.perform' do
-            subject { interactor_class.perform }
-
-            it { expect { subject }.not_to raise_error }
-            it { is_expected.to be_a model_mock }
-            it { is_expected.to be_failure }
-            it 'is expected to receive #rollback' do
-              expect_any_instance_of(interactor_class).to receive(:rollback)
-              subject
-            end
-          end
-
-          describe '.perform!' do
-            subject { interactor_class.perform! }
-
-            it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
-          end
-        end
-      end
-
-      describe 'a basic organizer using an ActiveRecord model class as context' do
-        let!(:model_mock) do
-          require 'active_model'
-          build_class('ModelMock', active_record_base_mock) do
-            include ActiveModel::Validations
-            attr_accessor :first_name, :last_name
-            acts_as_context
-          end
-        end
-
-        context 'with each organized interactor using the model' do
-          let!(:test_interactor_1) do
-            build_interactor('TestInteractor1') do
-              contextualize_with :model_mock
-
-              def perform
-                context.first_name = 'Test'
-              end
-            end
-          end
-
-          let!(:test_interactor_2) do
-            build_interactor('TestInteractor2') do
-              contextualize_with :model_mock
-
-              def perform
-                context.last_name = 'User'
-              end
-            end
-          end
-
-          let(:interactor_class) do
-            build_organizer do
-              contextualize_with :model_mock
-              organize :test_interactor_1, :test_interactor_2
-            end
-          end
-
-          include_examples 'a class with interactor methods'
-          include_examples 'a class with interactor callback methods'
-          include_examples 'a class with interactor context methods'
-          include_examples 'a class with organizer callback methods'
-
-          describe '.perform' do
-            subject { interactor_class.perform }
-
-            it { is_expected.to be_a model_mock }
-            it { is_expected.to be_successful }
-            it { is_expected.to have_attributes(first_name: 'Test', last_name: 'User') }
-          end
-        end
-
-        context 'with each organized interactor using their default context' do
-          let!(:test_interactor_1) do
-            build_interactor('TestInteractor1') do
-              def perform
-                context.first_name = 'Test'
-              end
-            end
-          end
-
-          let!(:test_interactor_2) do
-            build_interactor('TestInteractor2') do
-              def perform
-                context.last_name = 'User'
-              end
-            end
-          end
-
-          let(:interactor_class) do
-            build_organizer do
-              contextualize_with :model_mock
-              organize :test_interactor_1, :test_interactor_2
-            end
-          end
-
-          include_examples 'a class with interactor methods'
-          include_examples 'a class with interactor callback methods'
-          include_examples 'a class with interactor context methods'
-          include_examples 'a class with organizer callback methods'
-
-          describe '.perform' do
-            subject { interactor_class.perform }
-
-            it { is_expected.to be_a model_mock }
-            it { is_expected.to be_successful }
-            it { is_expected.to have_attributes(first_name: 'Test', last_name: 'User') }
-          end
-        end
+        include_examples 'A class that extends ActiveInteractor::Models'
       end
     end
   end