active_interaction 5.3.0 → 5.5.0

data/spec/active_interaction/concerns/missable_spec.rb

@@ -1,97 +0,0 @@
-RSpec.describe ActiveInteraction::Missable do
-  include_context 'concerns', described_class
-
-  describe '#respond_to?(slug, include_all = false)' do
-    context 'with invalid slug' do
-      let(:slug) { :slug }
-
-      it 'returns false' do
-        expect(instance).to_not respond_to(slug)
-      end
-    end
-
-    context 'with valid slug' do
-      let(:slug) { :boolean }
-
-      it 'returns true' do
-        expect(instance).to respond_to(slug)
-      end
-    end
-  end
-
-  describe '#method(sym)' do
-    context 'with invalid slug' do
-      let(:slug) { :slug }
-
-      it 'returns false' do
-        expect { instance.method(slug) }.to raise_error NameError
-      end
-    end
-
-    context 'with valid slug' do
-      let(:slug) { :boolean }
-
-      it 'returns true' do
-        expect(instance.method(slug)).to be_a Method
-      end
-    end
-  end
-
-  describe '#method_missing' do
-    context 'with invalid slug' do
-      let(:slug) { :slug }
-
-      it 'calls super' do
-        expect do
-          instance.public_send(slug)
-        end.to raise_error NameError
-      end
-    end
-
-    context 'with valid slug' do
-      let(:filter) { ActiveInteraction::Filter.factory(slug) }
-      let(:slug) { :boolean }
-
-      it 'returns self' do
-        expect(instance.public_send(slug)).to eql instance
-      end
-
-      it 'yields' do
-        expect do |b|
-          instance.public_send(slug, &b)
-        end.to yield_with_args(filter, [], {})
-      end
-
-      context 'with names' do
-        let(:names) { %i[a b c] }
-
-        it 'yields' do
-          expect do |b|
-            instance.public_send(:boolean, *names, &b)
-          end.to yield_with_args(filter, names, {})
-        end
-      end
-
-      context 'with options' do
-        let(:options) { { a: nil, b: false, c: true } }
-
-        it 'yields' do
-          expect do |b|
-            instance.public_send(:boolean, options, &b)
-          end.to yield_with_args(filter, [], options)
-        end
-      end
-
-      context 'with names & options' do
-        let(:names) { %i[a b c] }
-        let(:options) { { a: nil, b: false, c: true } }
-
-        it 'yields' do
-          expect do |b|
-            instance.public_send(:boolean, *names, options, &b)
-          end.to yield_with_args(filter, names, options)
-        end
-      end
-    end
-  end
-end

data/spec/active_interaction/concerns/runnable_spec.rb

@@ -1,395 +0,0 @@
-RSpec.describe ActiveInteraction::Runnable do
-  include_context 'concerns', described_class
-
-  class WrappableFailingInteraction # rubocop:disable Lint/ConstantDefinitionInBlock
-    include ActiveInteraction::Runnable
-
-    def execute
-      errors.add(:base)
-    end
-  end
-
-  shared_context 'with an error' do
-    before { instance.errors.add(:base) }
-  end
-
-  shared_context 'with a validator' do
-    before { klass.validate { errors.add(:base) } }
-  end
-
-  shared_context 'with #execute defined' do
-    before { klass.send(:define_method, :execute) { rand } }
-  end
-
-  context 'validations' do
-    describe '#runtime_errors' do
-      include_context 'with an error'
-
-      it 'is invalid' do
-        instance.result = nil
-        expect(instance).to_not be_valid
-      end
-
-      it 'becomes valid if errors are cleared' do
-        instance.result = nil
-        instance.errors.clear
-        instance.result = nil
-        expect(instance).to be_valid
-      end
-    end
-  end
-
-  context 'callbacks' do
-    describe '.set_callback' do
-      include_context 'with #execute defined'
-
-      shared_examples 'set_callback examples' do |name|
-        context name do
-          it 'does not raise an error' do
-            expect do
-              klass.set_callback name, :before, -> {}
-            end.to_not raise_error
-          end
-
-          %i[after around before].each do |type|
-            it type do
-              has_run = false
-
-              klass.set_callback name, type, -> { has_run = true }
-
-              klass.run
-              expect(has_run).to be_truthy
-            end
-          end
-        end
-      end
-
-      include_examples 'set_callback examples', :validate
-      include_examples 'set_callback examples', :execute
-
-      context 'execute with composed interaction' do
-        class WithFailingCompose # rubocop:disable Lint/ConstantDefinitionInBlock
-          include ActiveInteraction::Runnable
-
-          def execute
-            compose(WrappableFailingInteraction)
-          end
-        end
-
-        context 'around' do
-          it 'is yielded errors from composed interactions' do
-            block_result = nil
-            WithFailingCompose.set_callback :execute, :around do |_, block|
-              block_result = block.call
-            end
-
-            WithFailingCompose.run
-            expect(block_result).to be_an(ActiveInteraction::Errors)
-            expect(block_result).to include(:base)
-          end
-        end
-
-        context 'after' do
-          it 'is yielded errors from composed interactions' do
-            has_run = false
-            WithFailingCompose.set_callback :execute, :after do
-              has_run = true
-            end
-
-            WithFailingCompose.run
-            expect(has_run).to be_truthy
-          end
-
-          context 'using if' do
-            it 'yields errors to the if' do
-              has_run = false
-              WithFailingCompose.set_callback :execute, :after, if: -> { errors.any? } do
-                has_run = true
-              end
-
-              WithFailingCompose.run
-              expect(has_run).to be_truthy
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#errors' do
-    it 'returns the errors' do
-      expect(instance.errors).to be_an ActiveInteraction::Errors
-    end
-  end
-
-  describe '#execute' do
-    it 'raises an error' do
-      expect { instance.execute }.to raise_error NotImplementedError
-    end
-  end
-
-  describe '#result' do
-    it 'returns the result' do
-      expect(instance.result).to be_nil
-    end
-  end
-
-  describe '#result=' do
-    let(:result) { double }
-
-    it 'returns the result' do
-      expect((instance.result = result)).to eql result
-    end
-
-    it 'sets the result' do
-      instance.result = result
-      expect(instance.result).to eql result
-    end
-
-    context 'with an error' do
-      include_context 'with an error'
-
-      it 'sets the result' do
-        instance.result = result
-        expect(instance.result).to eql result
-      end
-    end
-
-    context 'with a validator' do
-      include_context 'with a validator'
-
-      it 'sets the result' do
-        instance.result = result
-        expect(instance.result).to eql result
-      end
-    end
-  end
-
-  describe '#valid?' do
-    let(:result) { double }
-
-    it 'returns true' do
-      expect(instance).to be_valid
-    end
-
-    context 'with an error' do
-      include_context 'with an error'
-
-      it 'returns true' do
-        expect(instance).to be_valid
-      end
-    end
-
-    context 'with a validator' do
-      include_context 'with a validator'
-
-      it 'returns false' do
-        expect(instance).to_not be_valid
-      end
-
-      it 'does not duplicate errors on subsequent calls' do
-        instance.valid?
-        count = instance.errors.count
-        instance.valid?
-
-        expect(instance.errors.count).to eql count
-      end
-    end
-  end
-
-  describe '.run' do
-    let(:outcome) { klass.run }
-
-    it 'raises an error' do
-      expect { outcome }.to raise_error NotImplementedError
-    end
-
-    context 'with #execute defined' do
-      include_context 'with #execute defined'
-
-      it 'returns an instance of Runnable' do
-        expect(outcome).to be_a klass
-      end
-
-      it 'sets the result' do
-        expect(outcome.result).to_not be_nil
-      end
-
-      context 'with a validator' do
-        include_context 'with a validator'
-
-        it 'returns an instance of Runnable' do
-          expect(outcome).to be_a klass
-        end
-
-        it 'sets the result to nil' do
-          expect(outcome.result).to be_nil
-        end
-      end
-    end
-
-    context 'caches the result of the run' do
-      context 'when it is invalid' do
-        let(:klass) do
-          Class.new(ActiveInteraction::Base) do
-            invalid = [false, true].cycle
-
-            validate do |interaction|
-              interaction.errors.add(:base, 'failed') unless invalid.next
-            end
-
-            def execute
-              true
-            end
-          end
-        end
-
-        it 'fails' do
-          expect(outcome).to_not be_valid
-          expect(outcome.result).to be_nil
-          expect(outcome).to_not be_valid
-          expect(outcome.result).to be_nil
-        end
-      end
-
-      context 'when it is valid' do
-        let(:klass) do
-          Class.new(ActiveInteraction::Base) do
-            valid = [true, false].cycle
-
-            validate do |interaction|
-              interaction.errors.add(:base, 'failed') unless valid.next
-            end
-
-            def execute
-              true
-            end
-          end
-        end
-
-        it 'succeeds' do
-          expect(outcome).to be_valid
-          expect(outcome.result).to be true
-          expect(outcome).to be_valid
-          expect(outcome.result).to be true
-        end
-      end
-    end
-
-    context 'with valid post-execution state' do
-      before do
-        klass.class_exec do
-          attr_accessor :attribute
-
-          validate { errors.add(:attribute) unless attribute }
-
-          def execute
-            self.attribute = true
-          end
-        end
-      end
-
-      it 'is invalid' do
-        expect(outcome).to_not be_valid
-      end
-
-      it 'stays invalid' do
-        outcome.attribute = false
-        expect(outcome).to_not be_valid
-      end
-    end
-
-    context 'with invalid post-execution state' do
-      before do
-        klass.class_exec do
-          attr_accessor :attribute
-
-          validate { errors.add(:attribute) if attribute }
-
-          def execute
-            self.attribute = true
-          end
-        end
-      end
-
-      it 'is valid' do
-        expect(outcome).to be_valid
-      end
-
-      it 'stays valid' do
-        outcome.attribute = true
-        expect(outcome).to be_valid
-      end
-    end
-
-    context 'with failing composition' do
-      class CheckInnerForFailure # rubocop:disable Lint/ConstantDefinitionInBlock
-        include ActiveInteraction::Runnable
-
-        attr_reader :caught_error
-
-        def execute
-          compose(WrappableFailingInteraction)
-        rescue StandardError
-          @caught_error = true
-          raise
-        end
-      end
-
-      it 'throws an error from the inner interaction' do
-        outcome = CheckInnerForFailure.run
-        expect(outcome.caught_error).to be true
-      end
-    end
-
-    context 'with block not called and error in execute around callback' do
-      class CheckExecuteAroundCallbackForFailure # rubocop:disable Lint/ConstantDefinitionInBlock
-        include ActiveInteraction::ActiveModelable
-        include ActiveInteraction::Runnable
-
-        set_callback :execute, :around, -> { errors.add(:base, 'invalid') }
-
-        def execute
-          true
-        end
-      end
-
-      it 'is invalid' do
-        outcome = CheckExecuteAroundCallbackForFailure.run
-        expect(outcome).to_not be_valid
-      end
-    end
-  end
-
-  describe '.run!' do
-    let(:result) { klass.run! }
-
-    it 'raises an error' do
-      expect { result }.to raise_error NotImplementedError
-    end
-
-    context 'with #execute defined' do
-      include_context 'with #execute defined'
-
-      it 'returns the result' do
-        expect(result).to_not be_nil
-      end
-
-      context 'with a validator' do
-        include_context 'with a validator'
-
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidInteractionError
-        end
-
-        it 'adds interaction instance to this error' do
-          expect { result }.to raise_error do |error|
-            expect(error.interaction).to be_a klass
-          end
-        end
-      end
-    end
-  end
-end

data/spec/active_interaction/errors_spec.rb

@@ -1,223 +0,0 @@
-require 'active_record'
-require 'sqlite3'
-
-ActiveRecord::Base.establish_connection(
-  adapter: 'sqlite3',
-  database: ':memory:'
-)
-
-RSpec.describe ActiveInteraction::Errors do
-  subject(:errors) { described_class.new(klass.new) }
-
-  let(:klass) do
-    Class.new(ActiveInteraction::Base) do
-      string :attribute, defualt: nil
-      array :array, defualt: nil
-
-      def self.name
-        @name ||= SecureRandom.hex
-      end
-    end
-  end
-
-  describe '#merge!' do
-    let(:other) { described_class.new(klass.new) }
-
-    context 'with an error' do
-      before do
-        other.add(:attribute)
-      end
-
-      it 'adds the error' do
-        errors.merge!(other)
-        expect(errors.messages[:attribute]).to eql ['is invalid']
-      end
-
-      it 'does not add duplicate errors' do
-        other.add(:attribute)
-        errors.merge!(other)
-        expect(errors.messages[:attribute]).to eql ['is invalid']
-      end
-
-      context 'that provides other options' do
-        let(:value) { SecureRandom.hex }
-        let(:error_name) { 'Some error' }
-
-        before do
-          other.add(:base, error_name, value: value)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: error_name, value: value }]
-        end
-      end
-    end
-
-    context 'with a detailed error' do
-      context 'that is a symbol' do
-        before do
-          other.add(:attribute)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:attribute]).to eql [{ error: :invalid }]
-        end
-      end
-
-      context 'that is a symbol on base' do
-        before do
-          other.add(:base)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: :invalid }]
-        end
-      end
-
-      context 'that is a string' do
-        let(:message) { SecureRandom.hex }
-
-        before do
-          other.add(:base, message)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: message }]
-        end
-      end
-
-      context 'that uses the :message option' do
-        let(:message) { SecureRandom.hex }
-        let(:error_name) { :some_error }
-
-        before do
-          other.add(:base, error_name, message: message)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: error_name }]
-          expect(errors.messages[:base]).to eql [message]
-        end
-      end
-
-      context 'that provides other options' do
-        let(:value) { SecureRandom.hex }
-        let(:error_name) { :some_error }
-
-        before do
-          other.add(:base, error_name, value: value)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: error_name, value: value }]
-        end
-      end
-    end
-
-    context 'with an interpolated detailed error' do
-      before do
-        I18n.backend.store_translations('en',
-          activemodel: {
-            errors: {
-              models: {
-                klass.name => {
-                  attributes: {
-                    attribute: {
-                      invalid_type: 'is not a valid %<type>s'
-                    }
-                  }
-                }
-              }
-            }
-          }
-        )
-
-        other.add(:attribute, :invalid_type, type: nil)
-      end
-
-      it 'does not raise an error' do
-        expect { errors.merge!(other) }.to_not raise_error
-      end
-    end
-
-    context 'with nested index errors' do
-      let(:other) { described_class.new(klass.new) }
-
-      before do
-        if ActiveRecord.respond_to?(:index_nested_attribute_errors)
-          allow(ActiveRecord).to receive(:index_nested_attribute_errors).and_return(true)
-        else
-          allow(ActiveRecord::Base).to receive(:index_nested_attribute_errors).and_return(true)
-        end
-
-        other.add(:'array[0]')
-      end
-
-      it 'adds the error' do
-        errors.merge!(other)
-        expect(errors.messages[:'array[0]']).to eql ['is invalid']
-      end
-    end
-
-    context 'with ActiveModel errors' do
-      let(:other) { ActiveModel::Errors.new(klass.new) }
-
-      it 'does not raise an error' do
-        expect { errors.merge!(other) }.to_not raise_error
-      end
-
-      it 'merges messages' do
-        message = SecureRandom.hex
-        other.add(:base, message)
-        errors.merge!(other)
-        expect(errors.messages[:base]).to include message
-      end
-    end
-
-    context 'with nested errors' do
-      let(:a_klass) do
-        Class.new(ActiveRecord::Base) do
-          has_one :b
-          accepts_nested_attributes_for :b
-        end
-      end
-      let(:a) { A.create(b_attributes: { name: nil }) }
-      let(:b_klass) do
-        Class.new(ActiveRecord::Base) do
-          belongs_to :a
-
-          validates :name, presence: true
-        end
-      end
-
-      before do
-        # suppress create_table output
-        allow($stdout).to receive(:puts)
-        ActiveRecord::Schema.define do
-          create_table(:as)
-          create_table(:bs) do |t|
-            t.column :a_id, :integer
-            t.column :name, :string
-          end
-        end
-
-        stub_const('A', a_klass)
-        stub_const('B', b_klass)
-      end
-
-      it 'merges the nested errors' do
-        a.valid?
-        expect(a.errors.messages).to eq('b.name': ["can't be blank"])
-        expect(a.errors.size).to be 1
-        expect { errors.merge!(a.errors) }.to_not raise_error
-        expect(errors.size).to be 1
-      end
-    end
-  end
-end