activeinteractor 1.2.1 → 1.2.2

data/spec/active_interactor/organizer/base_spec.rb

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Organizer::Base do
-  let(:interactor_class) { described_class }
-
-  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 '.contextualize_with' do
-    subject { described_class.contextualize_with(klass) }
-
-    context 'with an class that does not exist' do
-      let(:klass) { 'SomeClassThatDoesNotExist' }
-
-      it { expect { subject }.to raise_error(ActiveInteractor::Error::InvalidContextClass) }
-    end
-
-    context 'with context class TestContext' do
-      before { build_context }
-
-      context 'when passed as a string' do
-        let(:klass) { 'TestContext' }
-
-        it 'is expected to assign the appropriate context class' do
-          subject
-          expect(described_class.context_class).to eq TestContext
-        end
-      end
-
-      context 'when passed as a symbol' do
-        let(:klass) { :test_context }
-
-        it 'is expected to assign the appropriate context class' do
-          subject
-          expect(described_class.context_class).to eq TestContext
-        end
-      end
-
-      context 'when passed as a constant' do
-        let(:klass) { TestContext }
-
-        it 'is expected to assign the appropriate context class' do
-          subject
-          expect(described_class.context_class).to eq TestContext
-        end
-      end
-    end
-  end
-
-  describe '.organize' do
-    context 'with two existing interactors' do
-      let!(:interactor1) { build_interactor('TestInteractor1') }
-      let!(:interactor2) { build_interactor('TestInteractor2') }
-
-      context 'when interactors are passed as args' do
-        let(:organizer) do
-          build_organizer do
-            organize :test_interactor_1, :test_interactor_2
-          end
-        end
-
-        describe '.organized' do
-          subject { organizer.organized }
-
-          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
-        end
-      end
-
-      context 'when a block is passed' do
-        let(:organizer) do
-          build_organizer do
-            organize do
-              add :test_interactor_1
-              add :test_interactor_2
-            end
-          end
-        end
-
-        describe '.organized' do
-          subject { organizer.organized }
-
-          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
-        end
-      end
-    end
-  end
-
-  describe '.perform_in_parallel' do
-    subject do
-      build_organizer do
-        perform_in_parallel
-      end
-    end
-
-    it { is_expected.to have_attributes(parallel: true) }
-  end
-
-  describe '#perform' do
-    subject { interactor_class.perform }
-
-    context 'with two existing interactors' do
-      let!(:interactor1) { build_interactor('TestInteractor1') }
-      let!(:interactor2) { build_interactor('TestInteractor2') }
-      let(:interactor_class) do
-        build_organizer do
-          organize TestInteractor1, TestInteractor2
-        end
-      end
-
-      it { is_expected.to be_a interactor_class.context_class }
-
-      it 'is expected to receive #perform on both interactors' do
-        expect_any_instance_of(interactor1).to receive(:perform)
-        expect_any_instance_of(interactor2).to receive(:perform)
-        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 receive #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 receive #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
-            def perform
-              context.fail!
-            end
-          end
-        end
-
-        it { expect { subject }.not_to raise_error }
-        it { is_expected.to be_failure }
-        it { is_expected.to be_a interactor_class.context_class }
-
-        it 'is expected to receive #perform on the first interactor' do
-          expect_any_instance_of(interactor1).to receive(:perform)
-          subject
-        end
-
-        it 'is expected not to receive #perform on the second interactor' do
-          expect_any_instance_of(interactor2).not_to receive(:perform)
-          subject
-        end
-
-        it 'is expected to receive #rollback on the first interactor' do
-          expect_any_instance_of(interactor1).to receive(:rollback)
-          subject
-        end
-      end
-
-      context 'when the second interactor context fails' do
-        let!(:interactor2) do
-          build_interactor('TestInteractor2') do
-            def perform
-              context.fail!
-            end
-          end
-        end
-
-        it { expect { subject }.not_to raise_error }
-        it { is_expected.to be_failure }
-        it { is_expected.to be_a interactor_class.context_class }
-
-        it 'is expected to receive #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 to receive #rollback on both interactors' do
-          expect_any_instance_of(interactor1).to receive(:rollback)
-          expect_any_instance_of(interactor2).to receive(:rollback)
-          subject
-        end
-      end
-
-      context 'when the organizer is set to perform in parallel' do
-        let(:interactor_class) do
-          build_organizer do
-            perform_in_parallel
-
-            organize TestInteractor1, TestInteractor2
-          end
-        end
-
-        it { is_expected.to be_a interactor_class.context_class }
-
-        it 'is expected to receive #perform on both interactors' do
-          expect_any_instance_of(interactor1).to receive(:perform)
-          expect_any_instance_of(interactor2).to receive(:perform)
-          subject
-        end
-
-        context 'when the first interactor context fails' do
-          let!(:interactor1) do
-            build_interactor('TestInteractor1') do
-              def perform
-                context.fail!
-              end
-            end
-          end
-
-          it { expect { subject }.not_to raise_error }
-          it { is_expected.to be_failure }
-          it { is_expected.to be_a interactor_class.context_class }
-
-          it 'is expected to receive #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 to receive #rollback both interactors' do
-            expect_any_instance_of(interactor1).to receive(:rollback)
-            expect_any_instance_of(interactor2).to receive(:rollback)
-            subject
-          end
-        end
-
-        context 'when the second interactor context fails' do
-          let!(:interactor2) do
-            build_interactor('TestInteractor2') do
-              def perform
-                context.fail!
-              end
-            end
-          end
-
-          it { expect { subject }.not_to raise_error }
-          it { is_expected.to be_failure }
-          it { is_expected.to be_a interactor_class.context_class }
-
-          it 'is expected to receive #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 to receive #rollback on both interactors' do
-            expect_any_instance_of(interactor1).to receive(:rollback)
-            expect_any_instance_of(interactor2).to receive(:rollback)
-            subject
-          end
-        end
-      end
-    end
-  end
-end

data/spec/active_interactor/organizer/interactor_interface_collection_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Organizer::InteractorInterfaceCollection do
-  describe '#add' do
-    subject { instance.add(interactor) }
-
-    let(:instance) { described_class.new }
-
-    context 'with an interactor that does not exist' do
-      let(:interactor) { :an_interactor_that_does_not_exist }
-
-      it { expect { subject }.not_to(change { instance.collection.count }) }
-      it { is_expected.to be_a described_class }
-    end
-
-    context 'with an existing interactor' do
-      before { build_interactor }
-
-      context 'when interactors are passed as contants' do
-        let(:interactor) { TestInteractor }
-
-        it { expect { subject }.to change { instance.collection.count }.by(1) }
-        it { is_expected.to be_a described_class }
-
-        it 'is expected to add the appropriate interactor' do
-          subject
-          expect(instance.collection.first.interactor_class).to eq TestInteractor
-        end
-      end
-
-      context 'when interactors are passed as symbols' do
-        let(:interactor) { :test_interactor }
-
-        it { expect { subject }.to change { instance.collection.count }.by(1) }
-        it { is_expected.to be_a described_class }
-
-        it 'is expected to add the appropriate interactor' do
-          subject
-          expect(instance.collection.first.interactor_class).to eq TestInteractor
-        end
-      end
-
-      context 'when interactors are passed as strings' do
-        let(:interactor) { 'TestInteractor' }
-
-        it { expect { subject }.to change { instance.collection.count }.by(1) }
-        it { is_expected.to be_a described_class }
-
-        it 'is expected to add the appropriate interactor' do
-          subject
-          expect(instance.collection.first.interactor_class).to eq TestInteractor
-        end
-      end
-    end
-  end
-
-  describe '#concat' do
-    subject { instance.concat(interactors) }
-
-    let(:instance) { described_class.new }
-
-    context 'with two existing interactors' do
-      let!(:interactor1) { build_interactor('TestInteractor1') }
-      let!(:interactor2) { build_interactor('TestInteractor2') }
-      let(:interactors) { %i[test_interactor_1 test_interactor_2] }
-
-      it { expect { subject }.to change { instance.collection.count }.by(2) }
-
-      it 'is expected to add the appropriate interactors' do
-        subject
-        expect(instance.collection.first.interactor_class).to eq TestInteractor1
-        expect(instance.collection.last.interactor_class).to eq TestInteractor2
-      end
-    end
-  end
-end

data/spec/active_interactor/organizer/interactor_interface_spec.rb

@@ -1,235 +0,0 @@
-# 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 {: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 } }
-
-        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, :before => :other_method }' do
-        let(:options) { { if: :some_method, validate: false, before: :other_method } }
-
-        describe '#filters' do
-          subject { instance.filters }
-
-          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 }
-
-          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/version_spec.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Version do
-  describe '::MAJOR' do
-    subject(:major) { described_class::MAJOR }
-
-    it { is_expected.to be_a Integer }
-  end
-
-  describe '::MINOR' do
-    subject(:minor) { described_class::MINOR }
-
-    it { is_expected.to be_a Integer }
-  end
-
-  describe '::PATCH' do
-    subject(:patch) { described_class::PATCH }
-
-    it { is_expected.to be_a Integer }
-  end
-
-  describe '::PRE' do
-    subject(:pre) { described_class::PRE }
-
-    it 'is a String or Nil' do
-      expect([String, NilClass]).to include pre.class
-    end
-  end
-
-  describe '::META' do
-    subject(:meta) { described_class::META }
-
-    it 'is a String or Nil' do
-      expect([String, NilClass]).to include meta.class
-    end
-  end
-
-  describe '.gem_version' do
-    subject(:gem_version) { described_class.gem_version }
-
-    context 'when version is 1.0.0-beta.1+test' do
-      before do
-        stub_const('ActiveInteractor::Version::MAJOR', 1)
-        stub_const('ActiveInteractor::Version::MINOR', 0)
-        stub_const('ActiveInteractor::Version::PATCH', 0)
-        stub_const('ActiveInteractor::Version::PRE', 'beta.1')
-        stub_const('ActiveInteractor::Version::META', 'test')
-      end
-
-      it { is_expected.to eq '1.0.0.beta.1.test' }
-    end
-
-    context 'when version is 1.0.0+test' do
-      before do
-        stub_const('ActiveInteractor::Version::MAJOR', 1)
-        stub_const('ActiveInteractor::Version::MINOR', 0)
-        stub_const('ActiveInteractor::Version::PATCH', 0)
-        stub_const('ActiveInteractor::Version::PRE', nil)
-        stub_const('ActiveInteractor::Version::META', 'test')
-      end
-
-      it { is_expected.to eq '1.0.0' }
-    end
-  end
-
-  describe '.semver' do
-    subject(:semver) { described_class.semver }
-
-    context 'when version is 1.0.0' do
-      before do
-        stub_const('ActiveInteractor::Version::MAJOR', 1)
-        stub_const('ActiveInteractor::Version::MINOR', 0)
-        stub_const('ActiveInteractor::Version::PATCH', 0)
-        stub_const('ActiveInteractor::Version::PRE', nil)
-        stub_const('ActiveInteractor::Version::META', nil)
-      end
-
-      it { is_expected.to eq '1.0.0' }
-    end
-
-    context 'when version is 1.0.0-beta.1' do
-      before do
-        stub_const('ActiveInteractor::Version::MAJOR', 1)
-        stub_const('ActiveInteractor::Version::MINOR', 0)
-        stub_const('ActiveInteractor::Version::PATCH', 0)
-        stub_const('ActiveInteractor::Version::PRE', 'beta.1')
-        stub_const('ActiveInteractor::Version::META', nil)
-      end
-
-      it { is_expected.to eq '1.0.0-beta.1' }
-    end
-
-    context 'when version is 1.0.0-beta.1+test' do
-      before do
-        stub_const('ActiveInteractor::Version::MAJOR', 1)
-        stub_const('ActiveInteractor::Version::MINOR', 0)
-        stub_const('ActiveInteractor::Version::PATCH', 0)
-        stub_const('ActiveInteractor::Version::PRE', 'beta.1')
-        stub_const('ActiveInteractor::Version::META', 'test')
-      end
-
-      it { is_expected.to eq '1.0.0-beta.1+test' }
-    end
-
-    context 'when version is 1.0.0+test' do
-      before do
-        stub_const('ActiveInteractor::Version::MAJOR', 1)
-        stub_const('ActiveInteractor::Version::MINOR', 0)
-        stub_const('ActiveInteractor::Version::PATCH', 0)
-        stub_const('ActiveInteractor::Version::PRE', nil)
-        stub_const('ActiveInteractor::Version::META', 'test')
-      end
-
-      it { is_expected.to eq '1.0.0+test' }
-    end
-  end
-end