active_interaction 5.3.0 → 5.4.0

data/spec/active_interaction/filters/date_time_filter_spec.rb

@@ -1,187 +0,0 @@
-RSpec.describe ActiveInteraction::DateTimeFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  shared_context 'with format' do
-    let(:format) { '%d/%m/%Y %H:%M:%S %:z' }
-
-    before do
-      options[:format] = format
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Datetime' do
-      let(:value) { DateTime.new }
-
-      it 'returns the DateTime' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { '2011-12-13T14:15:16+17:18' }
-
-      it 'returns a DateTime' do
-        expect(result.value).to eql DateTime.parse(value)
-      end
-
-      context 'with format' do
-        include_context 'with format'
-
-        let(:value) { '13/12/2011 14:15:16 +17:18' }
-
-        it 'returns a DateTime' do
-          expect(result.value).to eql DateTime.strptime(value, format)
-        end
-      end
-    end
-
-    context 'with an invalid String' do
-      let(:value) { 'invalid' }
-
-      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
-
-      context 'with format' do
-        include_context 'with format'
-
-        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
-    end
-
-    context 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            '2011-12-13T14:15:16+17:18'
-          end
-        end.new
-      end
-
-      it 'returns a DateTime' do
-        expect(result.value).to eql DateTime.parse(value)
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            ' '
-          end
-        end.new
-      end
-
-      context 'optional' do
-        include_context 'optional'
-
-        it 'returns the default' do
-          expect(result.value).to eql options[:default]
-        end
-      end
-
-      context 'required' do
-        include_context 'required'
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :missing
-        end
-      end
-    end
-
-    context 'with a GroupedInput' do
-      let(:year) { 2012 }
-      let(:month) { 1 }
-      let(:day) { 2 }
-      let(:hour) { 3 }
-      let(:min) { 4 }
-      let(:sec) { 5 }
-      let(:value) do
-        ActiveInteraction::GroupedInput.new(
-          '1' => year.to_s,
-          '2' => month.to_s,
-          '3' => day.to_s,
-          '4' => hour.to_s,
-          '5' => min.to_s,
-          '6' => sec.to_s
-        )
-      end
-
-      it 'returns a DateTime' do
-        expect(
-          result.value
-        ).to eql DateTime.new(year, month, day, hour, min, sec)
-      end
-    end
-
-    context 'with an invalid GroupedInput' do
-      context 'empty' do
-        let(:value) { ActiveInteraction::GroupedInput.new }
-
-        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 'partial inputs' do
-        let(:value) do
-          ActiveInteraction::GroupedInput.new(
-            '2' => '1'
-          )
-        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
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :datetime' do
-      expect(filter.database_column_type).to be :datetime
-    end
-  end
-
-  describe '#default' do
-    context 'with a GroupedInput' do
-      before do
-        options[:default] = ActiveInteraction::GroupedInput.new(
-          '1' => '2012',
-          '2' => '1',
-          '3' => '2',
-          '4' => '3',
-          '5' => '4',
-          '6' => '5'
-        )
-      end
-
-      it 'raises an error' do
-        expect do
-          filter.default(nil)
-        end.to raise_error ActiveInteraction::InvalidDefaultError
-      end
-    end
-  end
-end

data/spec/active_interaction/filters/decimal_filter_spec.rb

@@ -1,124 +0,0 @@
-RSpec.describe ActiveInteraction::DecimalFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  shared_context 'with digits' do
-    let(:digits) { 4 }
-
-    before do
-      options[:digits] = digits
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Float' do
-      let(:value) { rand }
-
-      it 'returns the BigDecimal' do
-        expect(result.value).to eql BigDecimal(value, 0)
-      end
-
-      context 'with :digits option' do
-        include_context 'with digits'
-
-        let(:value) { 1.23456789 }
-
-        it 'returns BigDecimal with given digits' do
-          expect(result.value).to eql BigDecimal('1.235')
-        end
-      end
-    end
-
-    context 'with an implicit Integer' do
-      let(:value) do
-        Class.new do
-          def to_int
-            @to_int ||= rand(1 << 16)
-          end
-        end.new
-      end
-
-      it 'returns a BigDecimal' do
-        expect(result.value).to eql BigDecimal(value.to_int)
-      end
-    end
-
-    context 'with a Numeric' do
-      let(:value) { rand(1 << 16) }
-
-      it 'returns a BigDecimal' do
-        expect(result.value).to eql BigDecimal(value)
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { rand.to_s }
-
-      it 'returns a BigDecimal' do
-        expect(result.value).to eql BigDecimal(value)
-      end
-    end
-
-    context 'with an invalid String' do
-      let(:value) { 'invalid' }
-
-      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 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            '1.1'
-          end
-        end.new
-      end
-
-      it 'returns a BigDecimal' do
-        expect(result.value).to eql BigDecimal(value)
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            ' '
-          end
-        end.new
-      end
-
-      context 'optional' do
-        include_context 'optional'
-
-        it 'returns the default' do
-          expect(result.value).to eql options[:default]
-        end
-      end
-
-      context 'required' do
-        include_context 'required'
-
-        it 'indicates an error' do
-          error = result.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 :decimal' do
-      expect(filter.database_column_type).to be :decimal
-    end
-  end
-end

data/spec/active_interaction/filters/file_filter_spec.rb

@@ -1,38 +0,0 @@
-RSpec.describe ActiveInteraction::FileFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a File' do
-      let(:value) { File.new(__FILE__) }
-
-      it 'returns the File' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a Tempfile' do
-      let(:value) { Tempfile.new(SecureRandom.hex) }
-
-      it 'returns the Tempfile' do
-        expect(result.value).to eq value
-      end
-    end
-
-    context 'with an object that responds to #rewind' do
-      let(:value) { double(rewind: nil) } # rubocop:disable RSpec/VerifiedDoubles
-
-      it 'returns the object' do
-        expect(result.value).to eq value
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :file' do
-      expect(filter.database_column_type).to be :file
-    end
-  end
-end

data/spec/active_interaction/filters/float_filter_spec.rb

@@ -1,109 +0,0 @@
-require 'bigdecimal'
-
-RSpec.describe ActiveInteraction::FloatFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Float' do
-      let(:value) { rand }
-
-      it 'returns the Float' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with an implicit Integer' do
-      let(:value) do
-        Class.new do
-          def to_int
-            @to_int ||= rand(1 << 16)
-          end
-        end.new
-      end
-
-      it 'returns a Float' do
-        expect(result.value).to eql value.to_int.to_f
-      end
-    end
-
-    context 'with a Numeric' do
-      let(:value) { BigDecimal('1.2') }
-
-      it 'returns a Float' do
-        expect(result.value).to eql value.to_f
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { rand.to_s }
-
-      it 'returns a Float' do
-        expect(result.value).to eql Float(value)
-      end
-    end
-
-    context 'with an invalid String' do
-      let(:value) { 'invalid' }
-
-      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 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            '1.1'
-          end
-        end.new
-      end
-
-      it 'returns a Float' do
-        # apparently `Float()` doesn't do this even though `Integer()` does
-        expect(result.value).to eql Float(value.to_str)
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            ' '
-          end
-        end.new
-      end
-
-      context 'optional' do
-        include_context 'optional'
-
-        it 'returns the default' do
-          expect(result.value).to eql options[:default]
-        end
-      end
-
-      context 'required' do
-        include_context 'required'
-
-        it 'indicates an error' do
-          error = result.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 :float' do
-      expect(filter.database_column_type).to be :float
-    end
-  end
-end

data/spec/active_interaction/filters/hash_filter_spec.rb

@@ -1,127 +0,0 @@
-RSpec.describe ActiveInteraction::HashFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  context 'with a nested nameless filter' do
-    let(:block) { proc { hash } }
-
-    it 'raises an error' do
-      expect { filter }.to raise_error ActiveInteraction::InvalidFilterError
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Hash' do
-      let(:value) { {} }
-
-      it 'returns the Hash' do
-        expect(result.value).to eql value
-        expect(result.value).to be_an_instance_of HashWithIndifferentAccess
-      end
-    end
-
-    context 'with an implicit Hash' do
-      let(:value) do
-        Class.new do
-          def to_hash
-            {}
-          end
-        end.new
-      end
-
-      it 'returns the Hash' do
-        expect(result.value).to eql value.to_hash
-      end
-    end
-
-    context 'with a non-empty Hash' do
-      let(:value) { { a: {} } }
-
-      it 'returns an empty Hash' do
-        expect(result.value).to eql({})
-      end
-    end
-
-    context 'with a nested filter' do
-      let(:block) { proc { hash :a } }
-
-      context 'with a Hash' do
-        let(:value) { { 'a' => {} } }
-
-        it 'returns the Hash' do
-          expect(result.value).to eql value
-          expect(result.value).to be_an_instance_of HashWithIndifferentAccess
-        end
-
-        context 'with String keys' do
-          before do
-            value.stringify_keys!
-          end
-
-          it 'does not raise an error' do
-            expect { result }.to_not raise_error
-          end
-        end
-      end
-
-      context 'without a Hash' do
-        let(:k) { 'a' }
-        let(:v) { double }
-        let(:value) { { k => v } }
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(result.errors.size).to be 1
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.name).to be :"#{filter.name}.#{error.filter.name}"
-          expect(error.type).to be :invalid_type
-        end
-      end
-    end
-
-    context 'with :strip false' do
-      let(:options) { { strip: false } }
-
-      context 'with a non-empty Hash' do
-        let(:value) { { 'a' => {} } }
-
-        it 'returns an empty Hash' do
-          expect(result.value).to eql value
-        end
-      end
-    end
-  end
-
-  describe '#default' do
-    context 'with a Hash' do
-      before do
-        options[:default] = {}
-      end
-
-      it 'returns the Hash' do
-        expect(filter.default(nil)).to eql options[:default]
-      end
-    end
-
-    context 'with a non-empty Hash' do
-      before do
-        options[:default] = { a: {} }
-      end
-
-      it 'raises an error' do
-        expect do
-          filter.default(nil)
-        end.to raise_error ActiveInteraction::InvalidDefaultError
-      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/integer_filter_spec.rb

@@ -1,102 +0,0 @@
-RSpec.describe ActiveInteraction::IntegerFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with an Integer' do
-      let(:value) { rand(1 << 16) }
-
-      it 'returns the Integer' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a Numeric' do
-      let(:value) { rand(1 << 16) + rand }
-
-      it 'returns an Integer' do
-        expect(result.value).to eql value.to_i
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { rand(1 << 16).to_s }
-
-      it 'returns an Integer' do
-        expect(result.value).to eql Integer(value, 10)
-      end
-    end
-
-    context 'with an invalid String' do
-      let(:value) { 'invalid' }
-
-      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 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            '1'
-          end
-        end.new
-      end
-
-      it 'returns an Integer' do
-        expect(result.value).to eql Integer(value.to_str, 10)
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            ' '
-          end
-        end.new
-      end
-
-      context 'optional' do
-        include_context 'optional'
-
-        it 'returns the default' do
-          expect(result.value).to eql options[:default]
-        end
-      end
-
-      context 'required' do
-        include_context 'required'
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :missing
-        end
-      end
-    end
-
-    it 'supports different bases' do
-      expect(
-        described_class.new(name, base: 8).process('071', nil).value
-      ).to be 57
-      error = described_class.new(name, base: 8).process('081', nil).errors.first
-
-      expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-      expect(error.type).to be :invalid_type
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :integer' do
-      expect(filter.database_column_type).to be :integer
-    end
-  end
-end