active_interaction 5.3.0 → 5.5.0

data/spec/active_interaction/filter/column_spec.rb

@@ -1,85 +0,0 @@
-RSpec.describe ActiveInteraction::Filter::Column do
-  subject(:column) { described_class.intern(type) }
-
-  let(:type) { :float }
-
-  describe '.intern(type)' do
-    it 'returns the same object for each type' do
-      expect(described_class.intern(type)).to equal column
-    end
-
-    it 'returns different objects for different types' do
-      expect(described_class.intern(:integer)).to_not equal column
-    end
-  end
-
-  describe '.new(type)' do
-    it 'is private' do
-      expect { described_class.new(type) }.to raise_error NoMethodError
-    end
-  end
-
-  describe '#limit' do
-    it 'returns nil' do
-      expect(column.limit).to be_nil
-    end
-  end
-
-  describe '#type' do
-    it 'returns the type' do
-      expect(column.type).to eql type
-    end
-  end
-
-  describe '#number?' do
-    let(:number?) { column.number? }
-
-    context 'type is' do
-      context ':integer' do
-        let(:type) { :integer }
-
-        it 'returns true' do
-          expect(number?).to be_truthy
-        end
-      end
-
-      context ':float' do
-        let(:type) { :float }
-
-        it 'returns true' do
-          expect(number?).to be_truthy
-        end
-      end
-
-      context 'anything else' do
-        let(:type) { :string }
-
-        it 'returns false' do
-          expect(number?).to be_falsey
-        end
-      end
-    end
-  end
-
-  describe '#text?' do
-    let(:text?) { column.text? }
-
-    context 'type is' do
-      context ':string' do
-        let(:type) { :string }
-
-        it 'returns true' do
-          expect(text?).to be_truthy
-        end
-      end
-
-      context 'anything else' do
-        let(:type) { :float }
-
-        it 'returns false' do
-          expect(text?).to be_falsey
-        end
-      end
-    end
-  end
-end

data/spec/active_interaction/filter_spec.rb

@@ -1,58 +0,0 @@
-RSpec.describe ActiveInteraction::Filter, :filter do
-  include_context 'filters'
-
-  describe '#database_column_type' do
-    it 'returns `:string`' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-
-  context 'with an unregistered subclass' do
-    let(:klass) { Class.new(described_class) }
-
-    describe '.slug' do
-      it 'is nil' do
-        expect(klass.slug).to be_nil
-      end
-    end
-  end
-
-  context 'with a registered subclass' do
-    let(:slug) { SecureRandom.hex.to_sym }
-    let(:described_class) do
-      s = slug
-      Class.new(ActiveInteraction::Filter) do
-        register s
-      end
-    end
-
-    it_behaves_like 'a filter'
-
-    describe '.slug' do
-      it 'returns the registered slug' do
-        expect(described_class.slug).to eql slug
-      end
-    end
-  end
-
-  describe '#default' do
-    subject(:filter) { ActiveInteraction::IntegerFilter.new(:test, default: default) }
-
-    context 'when it is a value' do
-      let(:default) { 1 }
-
-      it 'returns the default' do
-        expect(filter.default).to be 1
-      end
-    end
-
-    context 'when it is a proc' do
-      let(:default) { -> { i + 1 } }
-
-      it 'returns the default' do
-        expect(filter.default(double(i: 0))).to be 1 # rubocop:disable RSpec/VerifiedDoubles
-        expect(filter.default(double(i: 1))).to be 2 # rubocop:disable RSpec/VerifiedDoubles
-      end
-    end
-  end
-end

data/spec/active_interaction/filters/abstract_date_time_filter_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ActiveInteraction::AbstractDateTimeFilter, :filter do
-  include_context 'filters'
-
-  describe '#process' do
-    let(:value) { nil }
-
-    it 'raises an error' do
-      expect { filter.process(value, nil) }.to raise_error NameError
-    end
-  end
-end

data/spec/active_interaction/filters/abstract_numeric_filter_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ActiveInteraction::AbstractNumericFilter, :filter do
-  include_context 'filters'
-
-  describe '#process' do
-    let(:value) { nil }
-
-    it 'raises an error' do
-      expect { filter.process(value, nil) }.to raise_error NameError
-    end
-  end
-end

data/spec/active_interaction/filters/array_filter_spec.rb

@@ -1,248 +0,0 @@
-RSpec.describe ActiveInteraction::ArrayFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  context 'with multiple nested filters' do
-    let(:block) do
-      proc do
-        array
-        array
-      end
-    end
-
-    it 'raises an error' do
-      expect { filter }.to raise_error ActiveInteraction::InvalidFilterError
-    end
-  end
-
-  context 'with a nested name' do
-    let(:block) { proc { array :a } }
-
-    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 an Array' do
-      let(:value) { [] }
-
-      it 'returns an ArrayInput' do
-        expect(result).to be_an_instance_of ActiveInteraction::ArrayInput
-      end
-
-      it 'returns the Array' do
-        expect(result.value).to eql value
-      end
-
-      it 'has no children' do
-        expect(result.children).to eql []
-      end
-    end
-
-    context 'with an implicit Array' do
-      let(:value) do
-        Class.new do
-          def to_ary
-            [1, 2, 3]
-          end
-        end.new
-      end
-
-      it 'returns the Array' do
-        expect(result.value).to eql value.to_ary
-      end
-    end
-
-    context 'with a heterogenous Array' do
-      let(:value) { [[], false, 0.0, {}, 0, '', :''] }
-
-      it 'returns the Array' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a nested filter where the value transforms' do
-      let(:block) { proc { symbol } }
-      let(:name) { :test }
-      let(:value) { ['test'] }
-
-      it 'returns the transformed value' do
-        expect(result.value).to eql [:test]
-      end
-
-      it 'does not modify the original value' do
-        expect(result.value.object_id).to_not eql value.object_id
-        expect(value).to eql ['test']
-      end
-    end
-
-    context 'with a nested filter' do
-      let(:block) { proc { array } }
-
-      context 'with an Array' do
-        let(:child_value) { [] }
-        let(:value) { [child_value, child_value] }
-
-        it 'returns the Array' do
-          expect(result.value).to eql value
-        end
-
-        it 'has children' do
-          expect(result.children.size).to be 2
-          result.children.each do |child|
-            expect(child).to be_an_instance_of ActiveInteraction::ArrayInput
-            expect(child.value).to eql child_value
-          end
-        end
-
-        context 'given a nil value' do
-          let(:value) { nil }
-
-          it 'returns an error' do
-            error = result.errors.first
-
-            expect(result.value).to eql value
-            expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-            expect(error.type).to be :missing
-          end
-        end
-      end
-
-      context 'with an Array of Arrays' do
-        let(:value) { [[]] }
-
-        it 'returns the Array' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'with a heterogenous Array' do
-        let(:value) { [[], false, 0.0] }
-
-        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
-          expect(error.type).to be :invalid_type
-        end
-
-        context 'when :index_errors is true' do
-          before do
-            options[:index_errors] = true
-          end
-
-          it 'shows the index of where the error occurred' do
-            expect(result.errors.size).to be 2
-
-            result.errors.each.with_index(1) do |error, i|
-              expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-              expect(error.name).to be :"#{filter.name}[#{i}]"
-              expect(error.type).to be :invalid_type
-            end
-          end
-        end
-
-        context 'when ActiveRecord.index_nested_attribute_errors is true' do
-          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
-          end
-
-          it 'shows the index of where the error occurred' do
-            expect(result.errors.size).to be 2
-
-            result.errors.each.with_index(1) do |error, i|
-              expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-              expect(error.name).to be :"#{filter.name}[#{i}]"
-              expect(error.type).to be :invalid_type
-            end
-          end
-
-          context 'when :index_errors is false' do
-            before do
-              options[:index_errors] = false
-            end
-
-            it 'does not attach the index' 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
-              expect(error.type).to be :invalid_type
-            end
-          end
-        end
-      end
-    end
-
-    [
-      %i[object class],
-      %i[record class],
-      %i[interface from]
-    ].each do |(type, option)|
-      context "with a nested #{type} filter" do
-        let(:block) { proc { public_send(type) } }
-        let(:name) { :objects }
-        let(:value) { [''] }
-
-        it 'does not raise an error' do
-          expect { result }.to_not raise_error
-        end
-
-        it 'has a filter with the right key' do
-          expect(filter.filters).to have_key(:'0')
-        end
-
-        it 'has a filter with the right option' do
-          expect(filter.filters[:'0'].options).to have_key(option)
-        end
-
-        context 'with a class set' do
-          let(:block) { proc { public_send(type, "#{option}": String) } }
-
-          it "does not override the #{option}" do
-            expect(filter.filters[:'0'].options[option]).to eql String
-          end
-        end
-      end
-    end
-
-    context 'with a nested interface type' do
-      context 'with the methods option set' do
-        let(:block) { proc { public_send(:interface, methods: %i[to_s]) } }
-
-        it 'has a filter with the right option' do
-          expect(filter.filters[:'0'].options).to have_key(:methods)
-          expect(filter.filters[:'0'].options[:methods]).to eql %i[to_s]
-        end
-      end
-
-      context 'with another option set' do
-        let(:block) { proc { public_send(:object, converter: :new) } }
-        let(:name) { :objects }
-
-        it 'has a filter with the right options' do
-          expect(filter.filters[:'0'].options).to have_key(:class)
-          expect(filter.filters[:'0'].options[:class]).to be :Object
-          expect(filter.filters[:'0'].options).to have_key(:converter)
-          expect(filter.filters[:'0'].options[:converter]).to be :new
-        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/boolean_filter_spec.rb

@@ -1,85 +0,0 @@
-RSpec.describe ActiveInteraction::BooleanFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    context 'falsey' do
-      [false, '0', 'false', 'FALSE', 'off', 'OFF'].each do |value|
-        it "returns false for #{value.inspect}" do
-          expect(filter.process(value, nil).value).to be_falsey
-        end
-      end
-
-      context 'with an implicit string' do
-        let(:value) do
-          Class.new do
-            def to_str
-              'false'
-            end
-          end.new
-        end
-
-        it 'returns false' do
-          expect(filter.process(value, nil).value).to be_falsey
-        end
-      end
-    end
-
-    context 'truthy' do
-      [true, '1', 'true', 'TRUE', 'on', 'ON'].each do |value|
-        it "returns true for #{value.inspect}" do
-          expect(filter.process(value, nil).value).to be_truthy
-        end
-      end
-
-      context 'with an implicit string' do
-        let(:value) do
-          Class.new do
-            def to_str
-              'true'
-            end
-          end.new
-        end
-
-        it 'returns true' do
-          expect(filter.process(value, nil).value).to be_truthy
-        end
-      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(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 :boolean' do
-      expect(filter.database_column_type).to be :boolean
-    end
-  end
-end

data/spec/active_interaction/filters/date_filter_spec.rb

@@ -1,176 +0,0 @@
-RSpec.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