activeinteractor 1.2.1 → 1.2.2

data/spec/active_interactor/context/base_spec.rb

@@ -1,443 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Context::Base do
-  describe '.attributes' do
-    context 'when no arguments are passed' do
-      subject { context_class.attributes }
-
-      let!(:context_class) { build_context }
-
-      it { is_expected.to eq [] }
-
-      context 'when an attribute :foo was previously defined' do
-        let!(:context_class) do
-          build_context do
-            attributes :foo
-          end
-        end
-
-        it { is_expected.to eq %i[foo] }
-      end
-    end
-
-    context 'when given arguments :foo and :bar' do
-      subject { context_class.attributes(:foo, :bar) }
-
-      let!(:context_class) { build_context }
-
-      it { is_expected.to eq %i[bar foo] }
-
-      context 'when an attribute :foo was previously defined' do
-        before { TestContext.attributes(:foo) }
-
-        it { is_expected.to eq %i[bar foo] }
-      end
-    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) }
-
-    context 'with class attributes []' do
-      let(:instance) { build_context.new }
-      let(:attribute) { :foo }
-
-      it { is_expected.to eq false }
-    end
-
-    context 'with class attributes [:foo]' do
-      let!(:context_class) do
-        build_context do
-          attributes :foo
-        end
-      end
-      let(:instance) { context_class.new }
-
-      context 'checking attribute :foo' do
-        let(:attribute) { :foo }
-
-        it { is_expected.to eq true }
-      end
-
-      context 'checking attribute :bar' do
-        let(:attribute) { :bar }
-
-        it { is_expected.to eq false }
-      end
-    end
-  end
-
-  describe '#attributes' do
-    subject { instance.attributes }
-
-    context 'with class attributes []' do
-      context 'with an instance having attributes { :foo => "foo", :bar => "bar", :baz => "baz" }' do
-        let(:instance) { described_class.new(foo: 'foo', bar: 'bar', baz: 'baz') }
-
-        it { is_expected.to be_a Hash }
-        it { is_expected.to be_empty }
-      end
-    end
-
-    context 'with class attributes [:foo, :bar, :baz]' do
-      before { build_context.attributes(:foo, :bar) }
-
-      context 'with an instance having attributes { :foo => "foo", :bar => "bar" }' do
-        let(:instance) { TestContext.new(foo: 'foo', bar: 'bar') }
-
-        it { is_expected.to be_a Hash }
-        it { is_expected.to eq(bar: 'bar', foo: 'foo') }
-      end
-
-      context 'with an instance having attributes { :foo => "foo", :bar => "bar", :baz => "baz" }' do
-        let(:instance) { TestContext.new(foo: 'foo', bar: 'bar', baz: 'baz') }
-
-        it { is_expected.to be_a Hash }
-        it { is_expected.to eq(bar: 'bar', foo: 'foo') }
-
-        it 'is expected to assign :baz' do
-          expect(instance.baz).to eq 'baz'
-        end
-      end
-    end
-  end
-
-  describe '#called!' do
-    subject do
-      instance.called!(interactor1)
-      instance.called!(interactor2)
-    end
-
-    let(:instance) { described_class.new }
-    let(:interactor1) { double(:interactor1) }
-    let(:interactor2) { double(:interactor2) }
-
-    it 'is expected to append interactors to instance variable _called' do
-      expect { subject }.to change { instance.send(:_called) }
-        .from([])
-        .to([interactor1, interactor2])
-    end
-  end
-
-  describe '#fail!' do
-    subject { instance.fail!(errors) }
-
-    let(:instance) { described_class.new }
-
-    context 'with errors equal to nil' do
-      let(:errors) { nil }
-
-      it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
-
-      it 'is expected not to merge errors' do
-        expect(instance.errors).not_to receive(:merge!).with(nil)
-        subject
-      rescue ActiveInteractor::Error::ContextFailure # rubocop:disable Lint/SuppressedException
-      end
-
-      it 'is expected to be a failure' do
-        subject
-      rescue ActiveInteractor::Error::ContextFailure
-        expect(instance).to be_a_failure
-      end
-    end
-
-    context 'with errors from another instance on the attribute :foo' do
-      let(:errors) { instance2.errors }
-      let(:instance2) { described_class.new }
-
-      before { instance2.errors.add(:foo, 'foo') }
-
-      it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
-
-      it 'is expected to merge errors' do
-        subject
-      rescue ActiveInteractor::Error::ContextFailure
-        expect(instance.errors[:foo]).to eq instance2.errors[:foo]
-      end
-
-      it 'is expected to be a failure' do
-        subject
-      rescue ActiveInteractor::Error::ContextFailure
-        expect(instance).to be_a_failure
-      end
-    end
-
-    context 'with errors "foo"' do
-      let(:errors) { 'foo' }
-
-      it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
-
-      it 'is expected to have error on :context equal to "foo"' do
-        subject
-      rescue ActiveInteractor::Error::ContextFailure
-        expect(instance.errors[:context]).to include 'foo'
-      end
-
-      it 'is expected to be a failure' do
-        subject
-      rescue ActiveInteractor::Error::ContextFailure
-        expect(instance).to be_a_failure
-      end
-    end
-  end
-
-  describe '#failure?' do
-    subject { instance.failure? }
-
-    let(:instance) { described_class.new }
-
-    it { is_expected.to eq false }
-
-    context 'when context has failed' do
-      before { instance.instance_variable_set('@_failed', true) }
-
-      it { is_expected.to eq true }
-    end
-  end
-
-  describe '#merge' do
-    subject { instance.merge!(attributes) }
-
-    context 'with an instance having attributes { :foo => "foo"}' do
-      let(:instance) { described_class.new(foo: 'foo') }
-
-      context 'with a hash having attributes { :bar => "bar"}' do
-        let(:attributes) { { bar: 'bar' } }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foo', bar: 'bar') }
-      end
-
-      context 'with a hash having attributes { :foo => "foobar"}' do
-        let(:attributes) { { foo: 'foobar' } }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foobar') }
-      end
-
-      context 'with a previous instance having attributes { :bar => "bar" }' do
-        let(:attributes) { described_class.new(bar: 'bar') }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foo', bar: 'bar') }
-
-        context 'having errors on :foo' do
-          before { attributes.errors.add(:foo, 'invalid') }
-
-          it 'is expected to have errors on :foo' do
-            expect(subject.errors[:foo]).not_to be_nil
-            expect(subject.errors[:foo]).to include 'invalid'
-          end
-        end
-
-        context 'having instance variable @_failed equal to true' do
-          before { attributes.instance_variable_set('@_failed', true) }
-
-          it { is_expected.to be_a described_class }
-          it { is_expected.to have_attributes(foo: 'foo') }
-
-          it 'is expected to preserve @_failed instance variable' do
-            expect(subject.instance_variable_get('@_failed')).to eq true
-          end
-        end
-
-        context 'having instance variable @_rolled_back equal to true' do
-          before { attributes.instance_variable_set('@_rolled_back', true) }
-
-          it { is_expected.to be_a described_class }
-          it { is_expected.to have_attributes(foo: 'foo') }
-
-          it 'is expected to preserve @_rolled_back instance variable' do
-            expect(subject.instance_variable_get('@_rolled_back')).to eq true
-          end
-        end
-      end
-
-      context 'with a previous instance having attributes { :foo => "foobar"}' do
-        let(:attributes) { described_class.new(foo: 'foobar') }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foobar') }
-      end
-
-      context 'having errors on :foo' do
-        before { instance.errors.add(:foo, 'invalid') }
-
-        context 'with a previous instance having attributes { :bar => "bar" }' do
-          let(:attributes) { described_class.new(bar: 'bar') }
-
-          it 'is expected to have errors on :foo' do
-            expect(subject.errors[:foo]).not_to be_nil
-            expect(subject.errors[:foo]).to include 'invalid'
-          end
-
-          context 'having errors on :bar' do
-            before { attributes.errors.add(:bar, 'invalid') }
-
-            it 'is expected to have errors on :foo' do
-              expect(subject.errors[:foo]).not_to be_nil
-              expect(subject.errors[:foo]).to include 'invalid'
-            end
-
-            it 'is expected to have errors on :bar' do
-              expect(subject.errors[:bar]).not_to be_nil
-              expect(subject.errors[:bar]).to include 'invalid'
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#new' do
-    subject { described_class.new(attributes) }
-
-    context 'with a hash having attributes { :foo => "foo"}' do
-      let(:attributes) { { foo: 'foo' } }
-
-      it { is_expected.to be_a described_class }
-      it { is_expected.to have_attributes(foo: 'foo') }
-    end
-
-    context 'with a previous instance having attributes { :foo => "foo" }' do
-      let(:attributes) { described_class.new(foo: 'foo') }
-
-      it { is_expected.to be_a described_class }
-      it { is_expected.to have_attributes(foo: 'foo') }
-
-      context 'having errors on :foo' do
-        before { attributes.errors.add(:foo, 'invalid') }
-
-        it { is_expected.to be_a described_class }
-
-        it 'is expected to have errors on :foo' do
-          expect(subject.errors[:foo]).not_to be_nil
-          expect(subject.errors[:foo]).to include 'invalid'
-        end
-      end
-
-      context 'having instance variable @_called equal to ["foo"]' do
-        before { attributes.instance_variable_set('@_called', %w[foo]) }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foo') }
-
-        it 'is expected to preserve @_called instance variable' do
-          expect(subject.instance_variable_get('@_called')).to eq %w[foo]
-        end
-      end
-
-      context 'having instance variable @_failed equal to true' do
-        before { attributes.instance_variable_set('@_failed', true) }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foo') }
-
-        it 'is expected to preserve @_failed instance variable' do
-          expect(subject.instance_variable_get('@_failed')).to eq true
-        end
-      end
-
-      context 'having instance variable @_rolled_back equal to true' do
-        before { attributes.instance_variable_set('@_rolled_back', true) }
-
-        it { is_expected.to be_a described_class }
-        it { is_expected.to have_attributes(foo: 'foo') }
-
-        it 'is expected to preserve @_rolled_back instance variable' do
-          expect(subject.instance_variable_get('@_rolled_back')).to eq true
-        end
-      end
-    end
-  end
-
-  describe '#rollback!' do
-    subject { instance.rollback! }
-
-    let(:instance) { described_class.new }
-
-    context 'with #called! interactors' do
-      let(:interactor1) { double(:interactor1) }
-      let(:interactor2) { double(:interactor2) }
-
-      before do
-        allow(instance).to receive(:_called).and_return([interactor1, interactor2])
-      end
-
-      it 'is expected to rollback each interactor in reverse order' do
-        expect(interactor2).to receive(:rollback).once.with(no_args).ordered
-        expect(interactor1).to receive(:rollback).once.with(no_args).ordered
-        subject
-      end
-
-      it 'is expected to ignore subsequent attempts' do
-        expect(interactor2).to receive(:rollback).once
-        expect(interactor1).to receive(:rollback).once
-        subject
-        subject
-      end
-    end
-  end
-
-  describe '#success?' do
-    subject { instance.success? }
-
-    let(:instance) { described_class.new }
-
-    it { is_expected.to eq true }
-
-    context 'when context has failed' do
-      before { instance.instance_variable_set('@_failed', true) }
-
-      it { is_expected.to eq false }
-    end
-  end
-end

data/spec/active_interactor/error_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Error::ContextFailure do
-  subject { described_class.new }
-
-  it { is_expected.to respond_to :context }
-
-  context 'when context is equal to nil' do
-    subject { described_class.new(nil) }
-
-    it { is_expected.to have_attributes(message: 'Context failed!') }
-  end
-
-  context 'when context is an instance of "TestContext"' do
-    subject { described_class.new(TestContext.new) }
-
-    before { build_context }
-
-    it { is_expected.to have_attributes(message: 'TestContext failed!') }
-
-    it 'is expected to have an instance of TestContext' do
-      expect(subject.context).to be_a TestContext
-    end
-  end
-end
-
-RSpec.describe ActiveInteractor::Error::InvalidContextClass do
-  subject { described_class.new }
-
-  it { is_expected.to respond_to :class_name }
-
-  context 'when class_name is equal to nil' do
-    subject { described_class.new(nil) }
-
-    it { is_expected.to have_attributes(message: 'invalid context class ') }
-  end
-
-  context 'when class_name is equal to "MyContect"' do
-    subject { described_class.new('MyContext') }
-
-    it { is_expected.to have_attributes(message: 'invalid context class MyContext') }
-  end
-end

data/spec/active_interactor/interactor/perform/options_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Interactor::Perform::Options do
-  subject { described_class.new }
-
-  it { is_expected.to respond_to :skip_each_perform_callbacks }
-  it { is_expected.to respond_to :skip_perform_callbacks }
-  it { is_expected.to respond_to :skip_rollback }
-  it { is_expected.to respond_to :skip_rollback_callbacks }
-  it { is_expected.to respond_to :validate }
-  it { is_expected.to respond_to :validate_on_calling }
-  it { is_expected.to respond_to :validate_on_called }
-
-  describe 'defaults' do
-    it { is_expected.to have_attributes(skip_each_perform_callbacks: false) }
-    it { is_expected.to have_attributes(skip_perform_callbacks: false) }
-    it { is_expected.to have_attributes(skip_rollback: false) }
-    it { is_expected.to have_attributes(skip_rollback_callbacks: false) }
-    it { is_expected.to have_attributes(validate: true) }
-    it { is_expected.to have_attributes(validate_on_calling: true) }
-    it { is_expected.to have_attributes(validate_on_called: true) }
-  end
-end

data/spec/active_interactor/interactor/worker_spec.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ActiveInteractor::Interactor::Worker do
-  context 'with interactor class TestInteractor' do
-    before { build_interactor }
-
-    let(:interactor) { TestInteractor.new }
-
-    RSpec.shared_examples 'an interactor with options' do
-      context 'when interactor has options :skip_perform_callbacks eq to true' do
-        let(:interactor) { TestInteractor.new.with_options(skip_perform_callbacks: true) }
-
-        it 'is expected not to receive #run_callbacks with :perform' do
-          allow_any_instance_of(TestInteractor).to receive(:run_callbacks)
-            .with(:validation).and_call_original
-          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-            .with(:perform)
-          subject
-        end
-      end
-
-      context 'when interactor has options :validate eq to false' do
-        let(:interactor) { TestInteractor.new.with_options(validate: false) }
-
-        it 'is expected not to receive #run_callbacks with :validation' do
-          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-            .with(:validation)
-          subject
-        end
-      end
-
-      context 'when interactor has options :validate_on_calling eq to false' do
-        let(:interactor) { TestInteractor.new.with_options(validate_on_calling: false) }
-
-        before do
-          allow_any_instance_of(TestInteractor).to receive(:context_valid?)
-            .with(:called).and_return(true)
-        end
-
-        it 'is expected not to receive #context_valid? with :calling' do
-          expect_any_instance_of(TestInteractor).not_to receive(:context_valid?)
-            .with(:calling)
-          subject
-        end
-
-        it 'is expected to receive #context_valid? with :called' do
-          expect_any_instance_of(TestInteractor).to receive(:context_valid?)
-            .with(:called)
-          subject
-        end
-      end
-
-      context 'when interactor has options :validate_on_called eq to false' do
-        let(:interactor) { TestInteractor.new.with_options(validate_on_called: false) }
-
-        before do
-          allow_any_instance_of(TestInteractor).to receive(:context_valid?)
-            .with(:calling).and_return(true)
-        end
-
-        it 'is expected to receive #context_valid? with :calling' do
-          expect_any_instance_of(TestInteractor).to receive(:context_valid?)
-            .with(:calling)
-          subject
-        end
-
-        it 'is expected not to receive #context_valid? with :called' do
-          expect_any_instance_of(TestInteractor).not_to receive(:context_valid?)
-            .with(:called)
-          subject
-        end
-      end
-    end
-
-    describe '#execute_perform' do
-      subject { described_class.new(interactor).execute_perform }
-
-      it { is_expected.to be_an TestInteractor.context_class }
-
-      context 'when context fails' do
-        before do
-          allow_any_instance_of(TestInteractor).to receive(:perform)
-            .and_raise(ActiveInteractor::Error::ContextFailure)
-        end
-
-        it { expect { subject }.not_to raise_error }
-        it { is_expected.to be_an TestInteractor.context_class }
-      end
-
-      include_examples 'an interactor with options'
-    end
-
-    describe '#execute_perform!' do
-      subject { described_class.new(interactor).execute_perform! }
-
-      it { is_expected.to be_an TestInteractor.context_class }
-
-      it 'is expected to run perform callbacks on interactor' do
-        expect_any_instance_of(TestInteractor).to receive(:run_callbacks)
-          .with(:perform)
-        subject
-      end
-
-      it 'is expected to receive #perform on interactor instance' do
-        expect_any_instance_of(TestInteractor).to receive(:perform)
-        subject
-      end
-
-      context 'when interactor context is invalid on :calling' do
-        before do
-          allow_any_instance_of(TestInteractor.context_class).to receive(:valid?)
-            .with(:calling)
-            .and_return(false)
-          allow_any_instance_of(TestInteractor.context_class).to receive(:valid?)
-            .with(:called)
-            .and_return(true)
-        end
-
-        it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
-
-        it 'is expected to rollback the interactor context' do
-          expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
-          expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure)
-        end
-      end
-
-      context 'when interactor context is invalid on :called' do
-        before do
-          allow_any_instance_of(TestInteractor.context_class).to receive(:valid?)
-            .with(:calling)
-            .and_return(true)
-          allow_any_instance_of(TestInteractor.context_class).to receive(:valid?)
-            .with(:called)
-            .and_return(false)
-        end
-
-        it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
-
-        it 'is expected to rollback the interactor context' do
-          expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
-          expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure)
-        end
-      end
-
-      include_examples 'an interactor with options'
-    end
-
-    describe '#execute_rollback' do
-      subject { described_class.new(interactor).execute_rollback }
-
-      it 'is expected to receive #run_callbacks on interactor with :rollback' do
-        expect_any_instance_of(TestInteractor).to receive(:run_callbacks)
-          .with(:rollback)
-        subject
-      end
-
-      it 'is expected to receive #context_rollback on interactor instance' do
-        expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
-        subject
-      end
-
-      context 'when interactor has options :skip_rollback eq to true' do
-        let(:interactor) { TestInteractor.new.with_options(skip_rollback: true) }
-
-        it 'is expected not to receive #context_rollback on interactor instance' do
-          expect_any_instance_of(TestInteractor).not_to receive(:context_rollback!)
-          subject
-        end
-      end
-
-      context 'when interactor has options :skip_rollback_callbacks eq to true' do
-        let(:interactor) { TestInteractor.new.with_options(skip_rollback_callbacks: true) }
-
-        it 'is expected to receive #context_rollback on interactor instance' do
-          expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
-          subject
-        end
-
-        it 'is expected not to receive #run_callbacks on interactor with :rollback' do
-          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-            .with(:rollback)
-          subject
-        end
-      end
-    end
-  end
-end