active_interaction 5.1.0 → 5.5.0

data/spec/active_interaction/filters/hash_filter_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-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,104 +0,0 @@
-require 'spec_helper'
-
-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

data/spec/active_interaction/filters/interface_filter_spec.rb

@@ -1,461 +0,0 @@
-require 'spec_helper'
-
-module InterfaceModule; end
-
-class InterfaceClass; end # rubocop:disable Lint/EmptyClass
-
-describe ActiveInteraction::InterfaceFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter' do
-    let(:name) { :interface_module }
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with an implicit constant name' do
-      context 'passed an instance' do
-        context 'with the module included' do
-          let(:name) { :interface_module }
-          let(:value) do
-            Class.new do
-              include InterfaceModule
-            end.new
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'with the class inherited from' do
-          let(:name) { :interface_class }
-          let(:value) do
-            Class.new(InterfaceClass) {}.new # rubocop:disable Lint/EmptyBlock
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that is extended by the ancestor' do
-          let(:name) { :interface_module }
-          let(:value) do
-            Class.new {}.new.extend(InterfaceModule) # rubocop:disable Lint/EmptyBlock
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that does not match' do
-          let(:name) { :interface_module }
-          let(:value) { Class.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 'that is nil' do
-          let(:name) { :interface_module }
-          let(:value) { nil }
-
-          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
-
-        context 'with the class itself' do
-          let(:name) { :interface_class }
-          let(:value) do
-            InterfaceClass.new
-          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
-
-      context 'passed a class' do
-        context 'with the class inherited from' do
-          let(:name) { :interface_class }
-          let(:value) do
-            Class.new(InterfaceClass) {} # rubocop:disable Lint/EmptyBlock
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that is extended by the ancestor' do
-          let(:name) { :interface_module }
-          let(:value) do
-            Class.new do
-              extend InterfaceModule
-            end
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that does not match' do
-          let(:name) { :interface_class }
-          let(:value) { Class }
-
-          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 the class itself' do
-          let(:name) { :interface_class }
-          let(:value) { InterfaceClass }
-
-          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 'passed a module' do
-        context 'that is extended by the ancestor' do
-          let(:name) { :interface_module }
-          let(:value) do
-            Module.new do
-              extend InterfaceModule
-            end
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that does not match' do
-          let(:name) { :interface_module }
-          let(:value) { Module.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 'with the module itself' do
-          let(:name) { :interface_module }
-          let(:value) { InterfaceModule }
-
-          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 'given an invalid name' do
-        let(:name) { :invalid }
-        let(:value) { Object }
-
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidNameError
-        end
-      end
-    end
-
-    context 'with a constant given' do
-      context 'passed an instance' do
-        context 'with the module included' do
-          before { options.merge!(from: :interface_module) }
-
-          let(:value) do
-            Class.new do
-              include InterfaceModule
-            end.new
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'with the class inherited from' do
-          before { options.merge!(from: :interface_class) }
-
-          let(:value) do
-            Class.new(InterfaceClass) {}.new # rubocop:disable Lint/EmptyBlock
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that is extended by the ancestor' do
-          before { options.merge!(from: :interface_module) }
-
-          let(:value) do
-            Class.new {}.new.extend(InterfaceModule) # rubocop:disable Lint/EmptyBlock
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that does not match' do
-          let(:name) { :interface_class }
-          let(:value) { Class.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 'with the class itself' do
-          let(:name) { :interface_class }
-          let(:value) { InterfaceClass.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
-      end
-
-      context 'passed a class' do
-        context 'with the class inherited from' do
-          before { options.merge!(from: :interface_class) }
-
-          let(:value) do
-            Class.new(InterfaceClass) {} # rubocop:disable Lint/EmptyBlock
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that is extended by the ancestor' do
-          before { options.merge!(from: :interface_module) }
-
-          let(:value) do
-            Class.new do
-              extend InterfaceModule
-            end
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that does not match' do
-          let(:name) { :interface_class }
-          let(:value) { Class }
-
-          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 the class itself' do
-          let(:name) { :interface_class }
-          let(:value) { InterfaceClass }
-
-          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 'passed a module' do
-        context 'that is extended by the ancestor' do
-          before { options.merge!(from: :interface_module) }
-
-          let(:value) do
-            Module.new do
-              extend InterfaceModule
-            end
-          end
-
-          it 'returns a the value' do
-            expect(result.value).to eql value
-          end
-        end
-
-        context 'that does not match' do
-          let(:name) { :interface_module }
-          let(:value) { Module.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 'with the module itself' do
-          let(:name) { :interface_module }
-          let(:value) { InterfaceModule }
-
-          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 'given an invalid name' do
-        before { options.merge!(from: :invalid) }
-
-        let(:value) { Object }
-
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidNameError
-        end
-      end
-    end
-
-    context 'with methods passed' do
-      before { options[:methods] = %i[dump load] }
-
-      context 'passed an valid instance' do
-        let(:value) do
-          Class.new do
-            def dump; end
-
-            def load; end
-          end.new
-        end
-
-        it 'returns a the value' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'passed an invalid instance' do
-        let(:value) { Class.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 'passed a class' do
-        let(:value) do
-          Class.new do
-            def self.dump; end
-
-            def self.load; end
-          end
-        end
-
-        it 'returns a the value' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'passed an invalid class' do
-        let(:value) { Class }
-
-        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 'passed a module' do
-        let(:value) do
-          Module.new do
-            def self.dump; end
-
-            def self.load; end
-          end
-        end
-
-        it 'returns a the value' do
-          expect(result.value).to eql value
-        end
-      end
-
-      context 'passed an invalid module' do
-        let(:value) { Module.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
-    end
-
-    context 'with from and methods passed' do
-      before do
-        options[:from] = :module
-        options[:methods] = %i[dump load]
-      end
-
-      it 'raises an error' do
-        expect do
-          filter
-        end.to raise_error ActiveInteraction::InvalidFilterError
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :string' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-end