active_interaction 5.1.0 → 5.5.0

data/spec/active_interaction/errors_spec.rb

@@ -1,196 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'sqlite3'
-
-ActiveRecord::Base.establish_connection(
-  adapter: 'sqlite3',
-  database: ':memory:'
-)
-
-describe ActiveInteraction::Errors do
-  subject(:errors) { described_class.new(klass.new) }
-
-  let(:klass) do
-    Class.new(ActiveInteraction::Base) do
-      string :attribute, defualt: nil
-      array :array, defualt: nil
-
-      def self.name
-        @name ||= SecureRandom.hex
-      end
-    end
-  end
-
-  describe '#merge!' do
-    let(:other) { described_class.new(klass.new) }
-
-    context 'with an error' do
-      before do
-        other.add(:attribute)
-      end
-
-      it 'adds the error' do
-        errors.merge!(other)
-        expect(errors.messages[:attribute]).to eql ['is invalid']
-      end
-
-      it 'does not add duplicate errors' do
-        other.add(:attribute)
-        errors.merge!(other)
-        expect(errors.messages[:attribute]).to eql ['is invalid']
-      end
-    end
-
-    context 'with a detailed error' do
-      context 'that is a symbol' do
-        before do
-          other.add(:attribute)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:attribute]).to eql [{ error: :invalid }]
-        end
-      end
-
-      context 'that is a symbol on base' do
-        before do
-          other.add(:base)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: :invalid }]
-        end
-      end
-
-      context 'that is a string' do
-        let(:message) { SecureRandom.hex }
-
-        before do
-          other.add(:base, message)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: message }]
-        end
-      end
-
-      context 'that uses the :message option' do
-        let(:message) { SecureRandom.hex }
-        let(:error_name) { :some_error }
-
-        before do
-          other.add(:base, error_name, message: message)
-        end
-
-        it 'adds the error' do
-          errors.merge!(other)
-          expect(errors.details[:base]).to eql [{ error: error_name }]
-          expect(errors.messages[:base]).to eql [message]
-        end
-      end
-    end
-
-    context 'with an interpolated detailed error' do
-      before do
-        I18n.backend.store_translations('en',
-          activemodel: {
-            errors: {
-              models: {
-                klass.name => {
-                  attributes: {
-                    attribute: {
-                      invalid_type: 'is not a valid %<type>s'
-                    }
-                  }
-                }
-              }
-            }
-          }
-        )
-
-        other.add(:attribute, :invalid_type, type: nil)
-      end
-
-      it 'does not raise an error' do
-        expect { errors.merge!(other) }.to_not raise_error
-      end
-    end
-
-    context 'with nested index errors' do
-      let(:other) { described_class.new(klass.new) }
-
-      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
-
-        other.add(:'array[0]')
-      end
-
-      it 'adds the error' do
-        errors.merge!(other)
-        expect(errors.messages[:'array[0]']).to eql ['is invalid']
-      end
-    end
-
-    context 'with ActiveModel errors' do
-      let(:other) { ActiveModel::Errors.new(klass.new) }
-
-      it 'does not raise an error' do
-        expect { errors.merge!(other) }.to_not raise_error
-      end
-
-      it 'merges messages' do
-        message = SecureRandom.hex
-        other.add(:base, message)
-        errors.merge!(other)
-        expect(errors.messages[:base]).to include message
-      end
-    end
-
-    context 'with nested errors' do
-      let(:a_klass) do
-        Class.new(ActiveRecord::Base) do
-          has_one :b
-          accepts_nested_attributes_for :b
-        end
-      end
-      let(:a) { A.create(b_attributes: { name: nil }) }
-      let(:b_klass) do
-        Class.new(ActiveRecord::Base) do
-          belongs_to :a
-
-          validates :name, presence: true
-        end
-      end
-
-      before do
-        # suppress create_table output
-        allow($stdout).to receive(:puts)
-        ActiveRecord::Schema.define do
-          create_table(:as)
-          create_table(:bs) do |t|
-            t.column :a_id, :integer
-            t.column :name, :string
-          end
-        end
-
-        stub_const('A', a_klass)
-        stub_const('B', b_klass)
-      end
-
-      it 'merges the nested errors' do
-        a.valid?
-        expect(a.errors.messages).to eq('b.name': ["can't be blank"])
-        expect(a.errors.size).to be 1
-        expect { errors.merge!(a.errors) }.to_not raise_error
-        expect(errors.size).to be 1
-      end
-    end
-  end
-end

data/spec/active_interaction/filter/column_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-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,39 +0,0 @@
-require 'spec_helper'
-
-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
-end

data/spec/active_interaction/filters/abstract_date_time_filter_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-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,13 +0,0 @@
-require 'spec_helper'
-
-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,245 +0,0 @@
-require 'spec_helper'
-
-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
-    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,87 +0,0 @@
-require 'spec_helper'
-
-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