activeinteractor 1.2.1 → 1.2.2

data/spec/active_interactor_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor do
-  describe '.config' do
-    subject { described_class.config }
-
-    it { is_expected.to be_a ActiveInteractor::Config }
-  end
-
-  describe '.configure' do
-    it 'is expected to yield config' do
-      expect { |b| described_class.configure(&b) }.to yield_control
-    end
-  end
-
-  describe '.logger' do
-    subject { described_class.logger }
-
-    it { is_expected.to be_a Logger }
-  end
-end

data/spec/integration/a_basic_interactor_spec.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'A basic interactor', type: :integration do
-  let(:interactor_class) do
-    build_interactor do
-      def perform
-        context.test_field = 'test'
-      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 TestInteractor::Context }
-    it { is_expected.to be < ActiveInteractor::Context::Base }
-  end
-
-  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 have_attributes(test_field: 'test') }
-  end
-
-  describe '.perform!' do
-    subject { interactor_class.perform! }
-
-    it { expect { subject }.not_to raise_error }
-    it { is_expected.to be_a interactor_class.context_class }
-    it { is_expected.to be_successful }
-    it { is_expected.to have_attributes(test_field: 'test') }
-  end
-
-  context 'having #context_attributes :test_field' do
-    let(:interactor_class) do
-      build_interactor do
-        context_attributes :test_field
-
-        def perform
-          context.test_field = 'test'
-          context.some_other_field = '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'
-
-    describe '.perform' do
-      subject(:result) { interactor_class.perform }
-
-      it { is_expected.to be_a interactor_class.context_class }
-      it { is_expected.to be_successful }
-      it { is_expected.to have_attributes(test_field: 'test', some_other_field: 'test 2') }
-
-      describe '.attributes' do
-        subject { result.attributes }
-
-        it { is_expected.to eq(test_field: 'test') }
-      end
-    end
-  end
-
-  context 'having a .name "AnInteractor"' do
-    let(:interactor_class) { build_interactor('AnInteractor') }
-
-    context 'having a class defined named "AnInteractorContext"' do
-      let!(:context_class) { build_context('AnInteractorContext') }
-
-      describe '.context_class' do
-        subject { interactor_class.context_class }
-
-        it { is_expected.to eq AnInteractorContext }
-        it { is_expected.to be < ActiveInteractor::Context::Base }
-      end
-    end
-  end
-
-  context 'with a context class named "ATestContext"' do
-    let!(:context_class) { build_context('ATestContext') }
-
-    context 'with .contextualize_with :a_test_context' do
-      let(:interactor_class) do
-        build_interactor do
-          contextualize_with :a_test_context
-        end
-      end
-
-      describe '.context_class' do
-        subject { interactor_class.context_class }
-
-        it { is_expected.to eq ATestContext }
-        it { is_expected.to be < ActiveInteractor::Context::Base }
-      end
-    end
-  end
-
-  context 'having default context attributes {:foo => "foo"}' do
-    let(:interactor_class) do
-      build_interactor do
-        context_attribute :foo, default: -> { 'foo' }
-      end
-    end
-
-    describe '.perform' do
-      subject { interactor_class.perform(context_attributes) }
-
-      context 'when no context is passed' do
-        let(:context_attributes) { {} }
-
-        it { is_expected.to have_attributes(foo: 'foo') }
-      end
-
-      context 'when context {:foo => "bar"} is passed' do
-        let(:context_attributes) { { foo: 'bar' } }
-
-        it { is_expected.to have_attributes(foo: 'bar') }
-      end
-    end
-  end
-
-  context 'having default context attributes {:foo => "foo", :bar => "bar"} using the #context_attributes method' do
-    let(:interactor_class) do
-      build_interactor do
-        context_attributes foo: { default: -> { 'foo' } }, bar: { default: -> { 'bar' } }
-      end
-
-      describe '.perform' do
-        subject { interactor_class.perform(context_attributes) }
-
-        context 'when no context is passed' do
-          let(:context_attributes) { {} }
-
-          it { is_expected.to have_attributes(foo: 'foo', bar: 'bar') }
-        end
-
-        context 'when context {:foo => "bar"} is passed' do
-          let(:context_attributes) { { foo: 'bar' } }
-
-          it { is_expected.to have_attributes(foo: 'bar', bar: 'bar') }
-        end
-      end
-    end
-  end
-end

data/spec/integration/a_basic_organizer_spec.rb

@@ -1,354 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'A basic organizer', type: :integration do
-  let!(:test_interactor_1) do
-    build_interactor('TestInteractor1') do
-      def perform
-        context.test_field_1 = 'test 1'
-      end
-    end
-  end
-
-  let!(:test_interactor_2) do
-    build_interactor('TestInteractor2') do
-      def perform
-        context.test_field_2 = 'test 2'
-      end
-    end
-  end
-
-  let(:interactor_class) do
-    build_organizer do
-      organize TestInteractor1, TestInteractor2
-    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 '.context_class' do
-    subject { interactor_class.context_class }
-
-    it { is_expected.to eq TestOrganizer::Context }
-    it { is_expected.to be < ActiveInteractor::Context::Base }
-  end
-
-  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 have_attributes(test_field_1: 'test 1', test_field_2: 'test 2') }
-  end
-
-  context 'when the first interactor fails' do
-    let!(:test_interactor_1) do
-      build_interactor('TestInteractor1') do
-        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 interactor_class.context_class }
-      it { is_expected.to be_failure }
-
-      it 'is expected to receive #rollback on the first interactor' do
-        expect_any_instance_of(test_interactor_1).to receive(:rollback)
-          .and_call_original
-        subject
-      end
-
-      it 'is expected not to receive #perform! on the second interactor' 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
-
-  context 'when the second interactor fails' do
-    let!(:test_interactor_2) do
-      build_interactor('TestInteractor2') do
-        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 interactor_class.context_class }
-      it { is_expected.to be_failure }
-
-      it 'is expected to receive #rollback on all interactors' do
-        expect_any_instance_of(test_interactor_2).to receive(:rollback)
-        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
-
-  # https://github.com/aaronmallen/activeinteractor/issues/151
-  context 'with an interactor class having a predefined context class with attributes [:foo]' do
-    let!(:test_context_class) do
-      build_context('TestInteractor1Context') do
-        attributes :foo
-        attributes :baz
-        attributes :zoo
-      end
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    let!(:test_interactor_1) do
-      build_interactor('TestInteractor1') do
-        def perform
-          context.has_foo_as_method = context.foo.present?
-          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
-    # rubocop:enable Metrics/AbcSize
-
-    let(:interactor_class) do
-      build_organizer do
-        organize :test_interactor_1
-      end
-    end
-
-    context 'when passing a context argument { :foo => "foo", :bar => "bar" }' do
-      let(:context_attributes) { { foo: 'foo', bar: 'bar' } }
-
-      describe '.perform' do
-        subject(:result) { interactor_class.perform(context_attributes) }
-
-        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
-          subject { result.attributes }
-
-          it { is_expected.to be_a Hash }
-          it { is_expected.to be_empty }
-        end
-      end
-
-      context 'with attributes [:foo] on the organizer context class' do
-        let!(:interactor_class) do
-          build_organizer do
-            context_attributes :foo
-            organize :test_interactor_1
-          end
-        end
-
-        describe '.perform' do
-          subject(:result) { interactor_class.perform(context_attributes) }
-
-          it { is_expected.to have_attributes(foo: 'foo', bar: 'bar') }
-
-          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
-          end
-
-          describe '#attributes' do
-            subject { result.attributes }
-
-            it { is_expected.to be_a Hash }
-            it { is_expected.to eq(foo: 'foo') }
-          end
-        end
-      end
-    end
-
-    context 'when passing default attributes on the organizer and its interactors' do
-      let!(:test_organizer_context_class) do
-        build_context('TestOrganizerContext') do
-          attribute :foo
-          attribute :baz
-          attribute :zoo, default: 'zoo'
-          attribute :taz, default: 'taz0'
-        end
-      end
-
-      let!(:test_interactor_3_context_class) do
-        build_context('TestInteractor3Context') do
-          attribute :foo
-          attribute :bar, default: 'bar'
-          attribute :baz, default: 'baz'
-          attribute :zoo
-          attribute :taz, default: 'taz3'
-        end
-      end
-
-      let!(:test_interactor_4_context_class) do
-        build_context('TestInteractor4Context') do
-          attribute :foo
-          attribute :bar, default: 'bar'
-          attribute :baz
-        end
-      end
-
-      let!(:test_interactor_3) do
-        build_interactor('TestInteractor3') do
-          def perform
-            context.bar = 'bar'
-            context.taz_is_set_at_3 = (context.taz == 'taz')
-            context.baz_is_set_at_3 = (context.baz == 'baz')
-            context.zoo_is_set_at_3 = (context.zoo == 'zoo')
-          end
-        end
-      end
-
-      let!(:test_interactor_4) do
-        build_interactor('TestInteractor4') do
-          def perform
-            context.taz_is_set_at_4 = (context.taz == 'taz')
-            context.baz_is_set_at_4 = (context.baz == 'baz')
-            context.zoo_is_set_at_4 = (context.zoo == 'zoo')
-          end
-        end
-      end
-
-      let!(:interactor_class) do
-        build_organizer('TestOrganizer') do
-          organize TestInteractor3, TestInteractor4
-        end
-      end
-
-      describe '.context_class' do
-        describe 'TestOrganizer' do
-          subject { interactor_class.context_class }
-
-          it { is_expected.to eq TestOrganizerContext }
-          it { is_expected.to be < ActiveInteractor::Context::Base }
-        end
-
-        describe 'TestInteractor3' do
-          subject { test_interactor_3.context_class }
-
-          it { is_expected.to eq TestInteractor3Context }
-          it { is_expected.to be < ActiveInteractor::Context::Base }
-        end
-
-        describe 'TestInteractor4' do
-          subject { test_interactor_4.context_class }
-
-          it { is_expected.to eq TestInteractor4Context }
-          it { is_expected.to be < ActiveInteractor::Context::Base }
-        end
-      end
-
-      describe '.perform' do
-        subject(:result) { interactor_class.perform(context_attributes) }
-
-        context 'when inputs are not defined' do
-          let(:context_attributes) { {} }
-
-          it { is_expected.to have_attributes(foo: nil, bar: 'bar', baz: 'baz') }
-        end
-
-        context 'when [:foo] is defined' do
-          let(:context_attributes) { { foo: 'foo' } }
-
-          it { is_expected.to have_attributes(foo: 'foo', bar: 'bar', baz: 'baz') }
-        end
-
-        context 'when [:taz] is defined' do
-          let(:context_attributes) { { taz: 'taz' } }
-
-          it { is_expected.to have_attributes(taz: 'taz', taz_is_set_at_3: true, taz_is_set_at_4: true) }
-        end
-
-        context 'when [:bar] is nil' do
-          let(:context_attributes) { { bar: nil } }
-
-          it { is_expected.to have_attributes(foo: nil, bar: 'bar', baz: 'baz') }
-        end
-
-        context 'when [:baz] is nil' do
-          let(:context_attributes) { {} }
-
-          it { is_expected.to have_attributes(baz: 'baz', baz_is_set_at_3: true, baz_is_set_at_4: true) }
-        end
-
-        context 'when [:zoo] is nil' do
-          let(:context_attributes) { {} }
-
-          it { is_expected.to have_attributes(zoo: 'zoo', zoo_is_set_at_3: true, zoo_is_set_at_4: true) }
-        end
-      end
-    end
-  end
-end

data/spec/integration/a_failing_interactor_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'A failing interactor', type: :integration do
-  let(:interactor_class) do
-    build_interactor do
-      def perform
-        context.fail!
-      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 TestInteractor::Context }
-    it { is_expected.to be < ActiveInteractor::Context::Base }
-  end
-
-  describe '.perform' do
-    subject { interactor_class.perform }
-
-    it { expect { subject }.not_to raise_error }
-    it { is_expected.to be_a interactor_class.context_class }
-    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

data/spec/integration/active_record_integration_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-begin
-  require 'active_interactor/rails'
-  require 'active_interactor/rails/orm/active_record'
-
-  RSpec.describe 'ActiveRecord integration', type: :integration do
-    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 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
-
-        include_examples 'A class that extends ActiveInteractor::Models'
-      end
-    end
-  end
-rescue LoadError
-  RSpec.describe 'ActiveRecord Integration', type: :integration do
-    pending 'Rails not found skipping specs...'
-  end
-end

data/spec/integration/an_interactor_with_after_context_validation_callbacks_spec.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'An interactor with .after_context_validation callbacks', type: :integration do
-  let(:interactor_class) do
-    build_interactor do
-      context_validates :test_field, presence: true
-      after_context_validation :downcase_test_field
-
-      private
-
-      def downcase_test_field
-        context.test_field = context.test_field.downcase
-      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 '.perform' do
-    subject { interactor_class.perform(context_attributes) }
-
-    context 'with valid context attributes' do
-      let(:context_attributes) { { test_field: 'TEST' } }
-
-      it { is_expected.to be_a interactor_class.context_class }
-      it { is_expected.to be_successful }
-      it { is_expected.to have_attributes(test_field: 'test') }
-    end
-  end
-
-  context 'having a condition on #after_context_valdation' do
-    let(:interactor_class) do
-      build_interactor do
-        context_validates :test_field, presence: true
-        after_context_validation :downcase_test_field, if: -> { context.should_downcase }
-
-        private
-
-        def downcase_test_field
-          context.test_field = context.test_field.downcase
-        end
-      end
-    end
-
-    describe '.perform' do
-      subject { interactor_class.perform(context_attributes) }
-
-      context 'with :test_field "TEST" and :should_downcase true' do
-        let(:context_attributes) { { test_field: 'TEST', should_downcase: true } }
-
-        it { is_expected.to be_a interactor_class.context_class }
-        it { is_expected.to be_successful }
-        it { is_expected.to have_attributes(test_field: 'test') }
-      end
-
-      context 'with :test_field "TEST" and :should_downcase false' do
-        let(:context_attributes) { { test_field: 'TEST', should_downcase: false } }
-
-        it { is_expected.to be_a interactor_class.context_class }
-        it { is_expected.to be_successful }
-        it { is_expected.to have_attributes(test_field: 'TEST') }
-      end
-    end
-  end
-end