activeinteractor 1.0.0.beta.3 → 1.0.0.beta.4

data/spec/active_interactor/organizer/interactor_interface_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ActiveInteractor::Organizer::InteractorInterface do
+  describe '.new' do
+    subject(:instance) { described_class.new(interactor_class, options) }
+
+    context 'with an interactor that does not exist' do
+      let(:interactor_class) { :an_interactor_that_does_not_exist }
+      let(:options) { {} }
+
+      describe '#interactor_class' do
+        subject { instance.interactor_class }
+
+        it { is_expected.to be_nil }
+      end
+    end
+
+    RSpec.shared_examples 'an instance of InteractorInterface correctly parse options' do
+      context 'with options {:if => :some_method }' do
+        let(:options) { { if: :some_method } }
+
+        describe '#filters' do
+          subject { instance.filters }
+
+          it { is_expected.to eq(if: :some_method) }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
+      context 'with options {:if => -> { context.test == true } }' do
+        let(:options) { { if: -> { context.test == true } } }
+
+        describe '#filters' do
+          subject { instance.filters }
+
+          it { expect(subject[:if]).not_to be_nil }
+          it { expect(subject[:if]).to be_a Proc }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
+      context 'with options {:unless => :some_method }' do
+        let(:options) { { unless: :some_method } }
+
+        describe '#filters' do
+          subject { instance.filters }
+
+          it { is_expected.to eq(unless: :some_method) }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to be_empty }
+        end
+      end
+
+      context 'with options {:unless => -> { context.test == true } }' do
+        let(:options) { { unless: -> { context.test == true } } }
+
+        describe '#filters' do
+          subject { instance.filters }
+
+          it { expect(subject[:unless]).not_to be_nil }
+          it { expect(subject[:unless]).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 } }
+
+        describe '#filters' do
+          subject { instance.filters }
+
+          it { is_expected.to be_empty }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to eq(validate: false) }
+        end
+      end
+
+      context 'with options { :if => :some_method, :validate => false }' do
+        let(:options) { { if: :some_method, validate: false } }
+
+        describe '#filters' do
+          subject { instance.filters }
+
+          it { is_expected.to eq(if: :some_method) }
+        end
+
+        describe '#perform_options' do
+          subject { instance.perform_options }
+
+          it { is_expected.to eq(validate: false) }
+        end
+      end
+    end
+
+    context 'with an existing interactor' do
+      before { build_interactor }
+
+      context 'when interactors are passed as contants' do
+        let(:interactor_class) { TestInteractor }
+        let(:options) { {} }
+
+        include_examples 'an instance of InteractorInterface correctly parse options'
+
+        describe '#interactor_class' do
+          subject { instance.interactor_class }
+
+          it { is_expected.to eq TestInteractor }
+        end
+      end
+
+      context 'when interactors are passed as symbols' do
+        let(:interactor_class) { :test_interactor }
+        let(:options) { {} }
+
+        include_examples 'an instance of InteractorInterface correctly parse options'
+
+        describe '#interactor_class' do
+          subject { instance.interactor_class }
+
+          it { is_expected.to eq TestInteractor }
+        end
+      end
+
+      context 'when interactors are passed as strings' do
+        let(:interactor_class) { 'TestInteractor' }
+        let(:options) { {} }
+        include_examples 'an instance of InteractorInterface correctly parse options'
+
+        describe '#interactor_class' do
+          subject { instance.interactor_class }
+
+          it { is_expected.to eq TestInteractor }
+        end
+      end
+    end
+  end
+end

data/spec/active_interactor/organizer_spec.rb

@@ -51,58 +51,46 @@ RSpec.describe ActiveInteractor::Organizer do
   end
 
   describe '.organize' do
-    subject { interactor_class }
     context 'with two existing interactors' do
       let!(:interactor1) { build_interactor('TestInteractor1') }
       let!(:interactor2) { build_interactor('TestInteractor2') }
 
-      context 'when interactors are passed as contants' do
-        let(:interactor_class) do
-          build_organizer do
-            organize TestInteractor1, TestInteractor2
-          end
-        end
-
-        it { is_expected.to have_attributes(organized: [TestInteractor1, TestInteractor2]) }
-      end
-
-      context 'when interactors are passed as symbols' do
-        let(:interactor_class) do
+      context 'when interactors are passed as args' do
+        let(:organizer) do
           build_organizer do
             organize :test_interactor_1, :test_interactor_2
           end
         end
 
-        it { is_expected.to have_attributes(organized: [TestInteractor1, TestInteractor2]) }
+        describe '.organized' do
+          subject { organizer.organized }
 
-        context 'having a non existance interactor' do
-          let(:interactor_class) do
-            build_organizer do
-              organize :test_interactor_1, :interactor_that_doesnt_exist, :test_interactor_2
-            end
+          it { expect(subject.collection).to all(be_a ActiveInteractor::Organizer::InteractorInterface) }
+          it 'is expected to organize the approriate interactors' do
+            expect(subject.collection.first.interactor_class).to eq TestInteractor1
+            expect(subject.collection.last.interactor_class).to eq TestInteractor2
           end
-
-          it { is_expected.to have_attributes(organized: [TestInteractor1, TestInteractor2]) }
         end
       end
 
-      context 'when interactors are passed as strings' do
-        let(:interactor_class) do
+      context 'when a block is passed' do
+        let(:organizer) do
           build_organizer do
-            organize 'TestInteractor1', 'TestInteractor2'
+            organize do
+              add :test_interactor_1
+              add :test_interactor_2
+            end
           end
         end
 
-        it { is_expected.to have_attributes(organized: [TestInteractor1, TestInteractor2]) }
+        describe '.organized' do
+          subject { organizer.organized }
 
-        context 'having a non existance interactor' do
-          let(:interactor_class) do
-            build_organizer do
-              organize 'TestInteractor1', 'InteractorThatDoesntExist', 'TestInteractor2'
-            end
+          it { expect(subject.collection).to all(be_a ActiveInteractor::Organizer::InteractorInterface) }
+          it 'is expected to organize the approriate interactors' do
+            expect(subject.collection.first.interactor_class).to eq TestInteractor1
+            expect(subject.collection.last.interactor_class).to eq TestInteractor2
           end
-
-          it { is_expected.to have_attributes(organized: [TestInteractor1, TestInteractor2]) }
         end
       end
     end
@@ -126,6 +114,22 @@ RSpec.describe ActiveInteractor::Organizer do
         subject
       end
 
+      context 'with options :skip_each_perform_callbacks eq to true' do
+        subject { interactor_class.perform({}, skip_each_perform_callbacks: true) }
+
+        it { is_expected.to be_a interactor_class.context_class }
+        it 'is expected to invoke #perform on both interactors' do
+          expect_any_instance_of(interactor1).to receive(:perform)
+          expect_any_instance_of(interactor2).to receive(:perform)
+          subject
+        end
+        it 'is expected not to invoke #run_callbacks with :each_perform' do
+          expect_any_instance_of(interactor_class).not_to receive(:run_callbacks)
+            .with(:each_perform)
+          subject
+        end
+      end
+
       context 'when the first interactor context fails' do
         let!(:interactor1) do
           build_interactor('TestInteractor1') do

data/spec/integration/basic_integration_spec.rb

@@ -115,12 +115,6 @@ RSpec.describe 'Basic Integration', type: :integration do
       it { is_expected.to be < ActiveInteractor::Context::Base }
     end
 
-    describe '.organized' do
-      subject { interactor_class.organized }
-
-      it { is_expected.to eq [TestInteractor1, TestInteractor2] }
-    end
-
     describe '.perform' do
       subject { interactor_class.perform }
 
@@ -254,12 +248,6 @@ RSpec.describe 'Basic Integration', type: :integration do
       it { is_expected.to be < ActiveInteractor::Context::Base }
     end
 
-    describe '.organized' do
-      subject { interactor_class.organized }
-
-      it { is_expected.to eq [TestInteractor1, TestInteractor2] }
-    end
-
     describe '.perform' do
       subject { interactor_class.perform }
 
@@ -268,4 +256,315 @@ RSpec.describe 'Basic Integration', type: :integration do
       it { is_expected.to have_attributes(test_field_1: 'test 1', test_field_2: 'test 2') }
     end
   end
+
+  describe 'A basic with conditionally organized interactors' do
+    let!(:test_interactor_1) { build_interactor('TestInteractor1') }
+    let!(:test_interactor_2)  { build_interactor('TestInteractor2') }
+
+    context 'with a condition on the first interactor { :if => -> { context.test_1 } } ' \
+    'and a condition on the second interactor { :if => -> { context.test_2 } }' do
+      let(:interactor_class) do
+        build_organizer do
+          organize do
+            add :test_interactor_1, if: -> { context.test_1 }
+            add :test_interactor_2, if: -> { context.test_2 }
+          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'
+      include_examples 'a class with organizer callback methods'
+
+      describe '.perform' do
+        subject { interactor_class.perform(context_attributes) }
+
+        context 'with context_attributes test_1 and test_2 both eq to true' do
+          let(:context_attributes) { { test_1: true, test_2: true } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected to invoke #perform on both interactors' do
+            expect_any_instance_of(test_interactor_1).to receive(:perform)
+            expect_any_instance_of(test_interactor_2).to receive(:perform)
+            subject
+          end
+        end
+
+        context 'with context_attributes test_1 eq to true and test_2 eq to false' do
+          let(:context_attributes) { { test_1: true, test_2: false } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_1).to receive(:perform)
+            subject
+          end
+
+          it 'is expected not to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_2).not_to receive(:perform)
+            subject
+          end
+        end
+
+        context 'with context_attributes test_1 eq to false and test_2 eq to true' do
+          let(:context_attributes) { { test_1: false, test_2: true } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected not to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_1).not_to receive(:perform)
+            subject
+          end
+
+          it 'is expected to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_2).to receive(:perform)
+            subject
+          end
+        end
+
+        context 'with context_attributes test_1 and test_2 both eq to false' do
+          let(:context_attributes) { { test_1: false, test_2: false } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected not to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_1).not_to receive(:perform)
+            subject
+          end
+
+          it 'is expected not to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_2).not_to receive(:perform)
+            subject
+          end
+        end
+      end
+    end
+
+    context 'with a condition on the first interactor { :unless => -> { context.test_1 } } ' \
+    'and a condition on the second interactor { :unless => -> { context.test_2 } }' do
+      let(:interactor_class) do
+        build_organizer do
+          organize do
+            add :test_interactor_1, unless: -> { context.test_1 }
+            add :test_interactor_2, unless: -> { context.test_2 }
+          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'
+      include_examples 'a class with organizer callback methods'
+
+      describe '.perform' do
+        subject { interactor_class.perform(context_attributes) }
+
+        context 'with context_attributes test_1 and test_2 both eq to true' do
+          let(:context_attributes) { { test_1: true, test_2: true } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected not to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_1).not_to receive(:perform)
+            subject
+          end
+
+          it 'is expected not to invoke #perform on the second interactor' do
+            expect_any_instance_of(test_interactor_2).not_to receive(:perform)
+            subject
+          end
+        end
+
+        context 'with context_attributes test_1 eq to true and test_2 eq to false' do
+          let(:context_attributes) { { test_1: true, test_2: false } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected not to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_1).not_to receive(:perform)
+            subject
+          end
+
+          it 'is expected to invoke #perform on the second interactor' do
+            expect_any_instance_of(test_interactor_2).to receive(:perform)
+            subject
+          end
+        end
+
+        context 'with context_attributes test_1 eq to false and test_2 eq to true' do
+          let(:context_attributes) { { test_1: false, test_2: true } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected to invoke #perform on the first interactor' do
+            expect_any_instance_of(test_interactor_1).to receive(:perform)
+            subject
+          end
+
+          it 'is expected not to invoke #perform on the second interactor' do
+            expect_any_instance_of(test_interactor_2).not_to receive(:perform)
+            subject
+          end
+        end
+
+        context 'with context_attributes test_1 and test_2 both eq to false' do
+          let(:context_attributes) { { test_1: false, test_2: false } }
+
+          it { is_expected.to be_a interactor_class.context_class }
+          it { is_expected.to be_successful }
+          it 'is expected to invoke #perform on both interactors' do
+            expect_any_instance_of(test_interactor_1).to receive(:perform)
+            expect_any_instance_of(test_interactor_2).to receive(:perform)
+            subject
+          end
+        end
+      end
+    end
+
+    context 'with a condition on the first interactor { :if => :test_method } and :test_method returning true' do
+      let(:interactor_class) do
+        build_organizer do
+          organize do
+            add :test_interactor_1, if: :test_method
+            add :test_interactor_2
+          end
+
+          private
+
+          def test_method
+            true
+          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'
+      include_examples 'a class with organizer callback methods'
+
+      describe '.perform' do
+        subject { interactor_class.perform }
+
+        it { is_expected.to be_a interactor_class.context_class }
+        it { is_expected.to be_successful }
+        it 'is expected to invoke #perform on both interactors' do
+          expect_any_instance_of(test_interactor_1).to receive(:perform)
+          expect_any_instance_of(test_interactor_2).to receive(:perform)
+          subject
+        end
+      end
+    end
+
+    context 'with a condition on the first interactor { :if => :test_method } and :test_method returning false' do
+      let(:interactor_class) do
+        build_organizer do
+          organize do
+            add :test_interactor_1, if: :test_method
+            add :test_interactor_2
+          end
+
+          private
+
+          def test_method
+            false
+          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'
+      include_examples 'a class with organizer callback methods'
+
+      describe '.perform' do
+        subject { interactor_class.perform }
+
+        it { is_expected.to be_a interactor_class.context_class }
+        it { is_expected.to be_successful }
+        it 'is expected not to invoke #perform on the first interactor' do
+          expect_any_instance_of(test_interactor_1).not_to receive(:perform)
+          subject
+        end
+
+        it 'is expected to invoke #perform on the second interactor' do
+          expect_any_instance_of(test_interactor_2).to receive(:perform)
+          subject
+        end
+      end
+    end
+
+    context 'with a condition on the first interactor { :unless => :test_method } and :test_method returning true' do
+      let(:interactor_class) do
+        build_organizer do
+          organize do
+            add :test_interactor_1, unless: :test_method
+            add :test_interactor_2
+          end
+
+          private
+
+          def test_method
+            true
+          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'
+      include_examples 'a class with organizer callback methods'
+
+      describe '.perform' do
+        subject { interactor_class.perform }
+
+        it { is_expected.to be_a interactor_class.context_class }
+        it { is_expected.to be_successful }
+        it 'is expected not to invoke #perform on the first interactor' do
+          expect_any_instance_of(test_interactor_1).not_to receive(:perform)
+          subject
+        end
+
+        it 'is expected to invoke #perform on the second interactor' do
+          expect_any_instance_of(test_interactor_2).to receive(:perform)
+          subject
+        end
+      end
+    end
+
+    context 'with a condition on the first interactor { :unless => :test_method } and :test_method returning false' do
+      let(:interactor_class) do
+        build_organizer do
+          organize do
+            add :test_interactor_1, unless: :test_method
+            add :test_interactor_2
+          end
+
+          private
+
+          def test_method
+            false
+          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'
+      include_examples 'a class with organizer callback methods'
+
+      describe '.perform' do
+        subject { interactor_class.perform }
+
+        it { is_expected.to be_a interactor_class.context_class }
+        it { is_expected.to be_successful }
+        it 'is expected to invoke #perform on both interactors' do
+          expect_any_instance_of(test_interactor_1).to receive(:perform)
+          expect_any_instance_of(test_interactor_2).to receive(:perform)
+          subject
+        end
+      end
+    end
+  end
 end