active_interaction 5.1.0 → 5.5.0

data/spec/active_interaction/filters/date_filter_spec.rb

@@ -1,178 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::DateFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  shared_context 'with format' do
-    let(:format) { '%d/%m/%Y' }
-
-    before do
-      options[:format] = format
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Date' do
-      let(:value) { Date.new }
-
-      it 'returns the Date' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { '2011-12-13' }
-
-      it 'returns a Date' do
-        expect(result.value).to eql Date.parse(value)
-      end
-
-      context 'with format' do
-        include_context 'with format'
-
-        let(:value) { '13/12/2011' }
-
-        it 'returns a Date' do
-          expect(result.value).to eql Date.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 'raises 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-13'
-          end
-        end.new
-      end
-
-      it 'returns a Date' do
-        expect(result.value).to eql Date.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(:value) do
-        ActiveInteraction::GroupedInput.new(
-          '1' => year.to_s,
-          '2' => month.to_s,
-          '3' => day.to_s
-        )
-      end
-
-      it 'returns a Date' do
-        expect(result.value).to eql Date.new(year, month, day)
-      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 'raises 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 :date' do
-      expect(filter.database_column_type).to be :date
-    end
-  end
-
-  describe '#default' do
-    context 'with a GroupedInput' do
-      before do
-        options[:default] = ActiveInteraction::GroupedInput.new(
-          '1' => '2012',
-          '2' => '1',
-          '3' => '2'
-        )
-      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/date_time_filter_spec.rb

@@ -1,189 +0,0 @@
-require 'spec_helper'
-
-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,126 +0,0 @@
-require 'spec_helper'
-
-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,40 +0,0 @@
-require 'spec_helper'
-
-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,110 +0,0 @@
-require 'bigdecimal'
-require 'spec_helper'
-
-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