active_interaction 5.1.0 → 5.5.0

data/spec/active_interaction/filters/object_filter_spec.rb

@@ -1,237 +0,0 @@
-require 'spec_helper'
-
-class ObjectThing
-  def self.converter(_)
-    @converter ||= new
-  end
-
-  def self.converter_with_error(_)
-    raise 'error'
-  end
-end
-
-class ObjectThings; end # rubocop:disable Lint/EmptyClass
-BackupObjectThing = ObjectThing
-
-describe ActiveInteraction::ObjectFilter, :filter do
-  include_context 'filters'
-  before do
-    options[:class] = ObjectThing
-  end
-
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:value) { ObjectThing.new }
-    let(:result) { filter.process(value, nil) }
-
-    context 'with an instance of the class' do
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-
-      context 'with an instance that is a subclass' do
-        let(:subclass) { Class.new(ObjectThing) }
-        let(:value) { subclass.new }
-
-        it 'returns the instance' do
-          expect(result.value).to eql value
-        end
-      end
-
-      it 'handles reconstantizing' do
-        expect(result.value).to eql value
-
-        Object.send(:remove_const, :ObjectThing)
-        ObjectThing = BackupObjectThing # rubocop:disable Lint/ConstantDefinitionInBlock
-        value = ObjectThing.new
-
-        expect(filter.process(value, nil).value).to eql value
-      end
-
-      it 'handles reconstantizing subclasses' do
-        filter
-
-        Object.send(:remove_const, :ObjectThing)
-        ObjectThing = BackupObjectThing # rubocop:disable Lint/ConstantDefinitionInBlock
-        class SubObjectThing < ObjectThing; end # rubocop:disable Lint/ConstantDefinitionInBlock
-        value = SubObjectThing.new
-
-        expect(filter.process(value, nil).value).to eql value
-      end
-
-      context 'without the class available' do
-        before { Object.send(:remove_const, :ObjectThing) }
-
-        after { ObjectThing = BackupObjectThing } # rubocop:disable Lint/ConstantDefinitionInBlock
-
-        it 'does not raise an error on initialization' do
-          expect { filter }.to_not raise_error
-        end
-      end
-    end
-
-    context 'with class as a String' do
-      before do
-        options[:class] = ObjectThing.name
-      end
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a plural class' do
-      let(:value) { ObjectThings.new }
-
-      before { options[:class] = ObjectThings }
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with class as an invalid String' do
-      before do
-        options[:class] = 'invalid'
-      end
-
-      it 'raises an error' do
-        expect do
-          result
-        end.to raise_error ActiveInteraction::InvalidNameError
-      end
-    end
-
-    context 'with a converter' do
-      let(:value) { '' }
-
-      context 'that is a symbol' do
-        before do
-          options[:converter] = :converter
-        end
-
-        it 'calls the class method' do
-          expect(result.value).to eql ObjectThing.converter(value)
-        end
-      end
-
-      context 'that is a proc' do
-        before do
-          options[:converter] = ->(x) { ObjectThing.converter(x) }
-        end
-
-        it 'gets called' do
-          expect(result.value).to eql ObjectThing.converter(value)
-        end
-      end
-
-      context 'with an object of the correct class' do
-        let(:value) { ObjectThing.new }
-
-        it 'does not call the converter' do
-          allow(ObjectThing).to receive(:converter)
-          result.value
-          expect(ObjectThing).to_not have_received(:converter)
-        end
-
-        it 'returns the correct value' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'with an object that is a subclass' do
-        let(:subclass) { Class.new(ObjectThing) }
-        let(:value) { subclass.new }
-
-        it 'does not call the converter' do
-          allow(subclass).to receive(:converter)
-          result.value
-          expect(subclass).to_not have_received(:converter)
-        end
-
-        it 'returns the correct value' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'with a nil value' do
-        let(:value) { nil }
-
-        include_context 'optional'
-
-        it 'returns nil' do
-          allow(ObjectThing).to receive(:converter)
-          result.value
-          expect(ObjectThing).to_not have_received(:converter)
-        end
-
-        it 'returns the correct value' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'that is invalid' do
-        before do
-          options[:converter] = 'invalid converter'
-        end
-
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidConverterError
-        end
-      end
-
-      context 'that throws an error' do
-        before do
-          options[:converter] = :converter_with_error
-        end
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-
-      context 'that returns a nil' do
-        let(:value) { '' }
-
-        before do
-          options[:default] = ObjectThing.new
-          options[:converter] = ->(_) {}
-        end
-
-        it 'indicates an error' do
-          error = filter.process(value, nil).errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-
-      context 'that returns an invalid value' do
-        let(:value) { '' }
-
-        before do
-          options[:converter] = ->(_) { 'invalid' }
-        end
-
-        it 'indicates an error' do
-          error = filter.process(value, nil).errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :string' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-end

data/spec/active_interaction/filters/record_filter_spec.rb

@@ -1,206 +0,0 @@
-require 'spec_helper'
-
-class RecordThing
-  def self.find(_)
-    raise 'error'
-  end
-
-  def self.finder(_)
-    @finder ||= new
-  end
-
-  def self.finds_nil(_)
-    nil
-  end
-
-  def self.finds_bad_value(_)
-    Object.new
-  end
-end
-
-class RecordThings; end # rubocop:disable Lint/EmptyClass
-BackupRecordThing = RecordThing
-
-describe ActiveInteraction::RecordFilter, :filter do
-  include_context 'filters'
-  before do
-    options[:class] = RecordThing
-  end
-
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:value) { RecordThing.new }
-    let(:result) { filter.process(value, nil) }
-
-    context 'with an instance of the class' do
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-
-      context 'with an instance that is a subclass' do
-        let(:subclass) { Class.new(RecordThing) }
-        let(:value) { subclass.new }
-
-        it 'returns the instance' do
-          expect(result.value).to eql value
-        end
-      end
-
-      it 'handles reconstantizing' do
-        expect(result.value).to eql value
-
-        Object.send(:remove_const, :RecordThing)
-        RecordThing = BackupRecordThing # rubocop:disable Lint/ConstantDefinitionInBlock
-        value = RecordThing.new
-
-        expect(filter.process(value, nil).value).to eql value
-      end
-
-      it 'handles reconstantizing subclasses' do
-        filter
-
-        Object.send(:remove_const, :RecordThing)
-        RecordThing = BackupRecordThing # rubocop:disable Lint/ConstantDefinitionInBlock
-        class SubRecordThing < RecordThing; end # rubocop:disable Lint/ConstantDefinitionInBlock
-        value = SubRecordThing.new
-
-        expect(filter.process(value, nil).value).to eql value
-      end
-
-      context 'without the class available' do
-        before { Object.send(:remove_const, :RecordThing) }
-
-        after { RecordThing = BackupRecordThing } # rubocop:disable Lint/ConstantDefinitionInBlock
-
-        it 'does not raise an error on initialization' do
-          expect { filter }.to_not raise_error
-        end
-      end
-    end
-
-    context 'with class as a superclass' do
-      before do
-        options[:class] = RecordThing.superclass
-      end
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with class as a String' do
-      before do
-        options[:class] = RecordThing.name
-      end
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a plural class' do
-      let(:value) { RecordThings.new }
-
-      before { options[:class] = RecordThings }
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with class as an invalid String' do
-      before do
-        options[:class] = 'invalid'
-      end
-
-      it 'raises an error' do
-        expect do
-          result
-        end.to raise_error ActiveInteraction::InvalidNameError
-      end
-    end
-
-    context 'with a value that does not match the class' do
-      let(:value) { 1 }
-
-      it 'calls the default finder' do
-        allow(RecordThing).to receive(:find)
-        result
-        expect(RecordThing).to have_received(:find).with(value)
-      end
-
-      context 'with a custom finder' do
-        before do
-          options[:finder] = :finder
-        end
-
-        it 'calls the custom finder' do
-          allow(RecordThing).to receive(:finder)
-          result
-          expect(RecordThing).to have_received(:finder).with(value)
-        end
-      end
-
-      context 'that returns a nil' do
-        let(:value) { 1 }
-
-        before do
-          options[:default] = RecordThing.new
-          options[:finder] = :finds_nil
-        end
-
-        it 'indicates an error' do
-          error = filter.process(value, nil).errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-
-      context 'that returns an invalid value' do
-        let(:value) { 1 }
-
-        before do
-          options[:finder] = :finds_bad_value
-        end
-
-        it 'indicates an error' do
-          error = filter.process(value, nil).errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) { ' ' }
-
-      context 'optional' do
-        include_context 'optional'
-
-        it 'returns the default' do
-          expect(filter.process(value, nil).value).to eql options[:default]
-        end
-      end
-
-      context 'required' do
-        include_context 'required'
-
-        it 'indicates an error' do
-          error = filter.process(value, nil).errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :missing
-        end
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :string' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-end

data/spec/active_interaction/filters/string_filter_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::StringFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  shared_context 'without strip' do
-    before do
-      options[:strip] = false
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a String' do
-      let(:value) { SecureRandom.hex }
-
-      it 'returns the String' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            @to_str ||= SecureRandom.hex
-          end
-        end.new
-      end
-
-      it 'returns the String' do
-        expect(result.value).to eql value.to_str
-      end
-    end
-
-    context 'with a strippable String' do
-      let(:value) { " #{SecureRandom.hex} " }
-
-      it 'returns the stripped string' do
-        expect(result.value).to eql value.strip
-      end
-
-      context 'without strip' do
-        include_context 'without strip'
-
-        it 'returns the String' do
-          expect(result.value).to eql value
-        end
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :string' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-end

data/spec/active_interaction/filters/symbol_filter_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::SymbolFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Symbol' do
-      let(:value) { SecureRandom.hex.to_sym }
-
-      it 'returns the Symbol' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with an implicit Symbol' do
-      let(:value) do
-        Class.new do
-          def to_sym
-            :symbol
-          end
-        end.new
-      end
-
-      it 'returns a symbol' do
-        expect(result.value).to eql value.to_sym
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { SecureRandom.hex }
-
-      it 'returns a Symbol' do
-        expect(result.value).to eql value.to_sym
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :string' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-end