active_interaction 5.3.0 → 5.4.0

data/spec/active_interaction/filters/record_filter_spec.rb

@@ -1,204 +0,0 @@
-class RecordThing
-  def self.find(_)
-    raise 'error'
-  end
-
-  def self.finder(_)
-    @finder ||= new
-  end
-
-  def self.finds_nil(_)
-    nil
-  end
-
-  def self.finds_bad_value(_)
-    Object.new
-  end
-end
-
-class RecordThings; end # rubocop:disable Lint/EmptyClass
-BackupRecordThing = RecordThing
-
-RSpec.describe ActiveInteraction::RecordFilter, :filter do
-  include_context 'filters'
-  before do
-    options[:class] = RecordThing
-  end
-
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:value) { RecordThing.new }
-    let(:result) { filter.process(value, nil) }
-
-    context 'with an instance of the class' do
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-
-      context 'with an instance that is a subclass' do
-        let(:subclass) { Class.new(RecordThing) }
-        let(:value) { subclass.new }
-
-        it 'returns the instance' do
-          expect(result.value).to eql value
-        end
-      end
-
-      it 'handles reconstantizing' do
-        expect(result.value).to eql value
-
-        Object.send(:remove_const, :RecordThing)
-        RecordThing = BackupRecordThing # rubocop:disable Lint/ConstantDefinitionInBlock
-        value = RecordThing.new
-
-        expect(filter.process(value, nil).value).to eql value
-      end
-
-      it 'handles reconstantizing subclasses' do
-        filter
-
-        Object.send(:remove_const, :RecordThing)
-        RecordThing = BackupRecordThing # rubocop:disable Lint/ConstantDefinitionInBlock
-        class SubRecordThing < RecordThing; end # rubocop:disable Lint/ConstantDefinitionInBlock
-        value = SubRecordThing.new
-
-        expect(filter.process(value, nil).value).to eql value
-      end
-
-      context 'without the class available' do
-        before { Object.send(:remove_const, :RecordThing) }
-
-        after { RecordThing = BackupRecordThing } # rubocop:disable Lint/ConstantDefinitionInBlock
-
-        it 'does not raise an error on initialization' do
-          expect { filter }.to_not raise_error
-        end
-      end
-    end
-
-    context 'with class as a superclass' do
-      before do
-        options[:class] = RecordThing.superclass
-      end
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with class as a String' do
-      before do
-        options[:class] = RecordThing.name
-      end
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a plural class' do
-      let(:value) { RecordThings.new }
-
-      before { options[:class] = RecordThings }
-
-      it 'returns the instance' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with class as an invalid String' do
-      before do
-        options[:class] = 'invalid'
-      end
-
-      it 'raises an error' do
-        expect do
-          result
-        end.to raise_error ActiveInteraction::InvalidNameError
-      end
-    end
-
-    context 'with a value that does not match the class' do
-      let(:value) { 1 }
-
-      it 'calls the default finder' do
-        allow(RecordThing).to receive(:find)
-        result
-        expect(RecordThing).to have_received(:find).with(value)
-      end
-
-      context 'with a custom finder' do
-        before do
-          options[:finder] = :finder
-        end
-
-        it 'calls the custom finder' do
-          allow(RecordThing).to receive(:finder)
-          result
-          expect(RecordThing).to have_received(:finder).with(value)
-        end
-      end
-
-      context 'that returns a nil' do
-        let(:value) { 1 }
-
-        before do
-          options[:default] = RecordThing.new
-          options[:finder] = :finds_nil
-        end
-
-        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 :invalid_type
-        end
-      end
-
-      context 'that returns an invalid value' do
-        let(:value) { 1 }
-
-        before do
-          options[:finder] = :finds_bad_value
-        end
-
-        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 :invalid_type
-        end
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) { ' ' }
-
-      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 :string' do
-      expect(filter.database_column_type).to be :string
-    end
-  end
-end

data/spec/active_interaction/filters/string_filter_spec.rb

@@ -1,58 +0,0 @@
-RSpec.describe ActiveInteraction::StringFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  shared_context 'without strip' do
-    before do
-      options[:strip] = false
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a String' do
-      let(:value) { SecureRandom.hex }
-
-      it 'returns the String' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            @to_str ||= SecureRandom.hex
-          end
-        end.new
-      end
-
-      it 'returns the String' do
-        expect(result.value).to eql value.to_str
-      end
-    end
-
-    context 'with a strippable String' do
-      let(:value) { " #{SecureRandom.hex} " }
-
-      it 'returns the stripped string' do
-        expect(result.value).to eql value.strip
-      end
-
-      context 'without strip' do
-        include_context 'without strip'
-
-        it 'returns the String' do
-          expect(result.value).to eql value
-        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/symbol_filter_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe ActiveInteraction::SymbolFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Symbol' do
-      let(:value) { SecureRandom.hex.to_sym }
-
-      it 'returns the Symbol' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with an implicit Symbol' do
-      let(:value) do
-        Class.new do
-          def to_sym
-            :symbol
-          end
-        end.new
-      end
-
-      it 'returns a symbol' do
-        expect(result.value).to eql value.to_sym
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { SecureRandom.hex }
-
-      it 'returns a Symbol' do
-        expect(result.value).to eql value.to_sym
-      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/time_filter_spec.rb

@@ -1,249 +0,0 @@
-RSpec.describe ActiveInteraction::TimeFilter, :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 '#initialize' do
-    context 'with a format' do
-      before { options[:format] = '%T' }
-
-      context 'with a time zone' do
-        before do
-          time_with_zone = double
-
-          time_zone = double
-          allow(time_zone).to receive(:at).and_return(time_with_zone)
-
-          allow(Time).to receive(:zone).and_return(time_zone)
-        end
-
-        it 'raises an error' do
-          expect do
-            filter
-          end.to raise_error(ActiveInteraction::InvalidFilterError)
-        end
-      end
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Time' do
-      let(:value) { Time.new }
-
-      it 'returns the Time' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { '2011-12-13 14:15:16 +1718' }
-
-      it 'returns a Time' do
-        expect(result.value).to eql Time.parse(value)
-      end
-
-      context 'with a time zone' do
-        before do
-          klass = double
-          allow(klass).to receive(:parse).with(value).and_return(nil)
-
-          allow(filter).to receive(:matches?).and_return(false)
-          allow(filter).to receive(:klass).and_return(klass)
-        end
-
-        it 'indicates an error the string is not parsable' 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 format' do
-        include_context 'with format'
-
-        let(:value) { '13/12/2011 14:15:16 +1718' }
-
-        it 'returns a Time' do
-          expect(result.value).to eql Time.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-13 14:15:16 +1718'
-          end
-        end.new
-      end
-
-      it 'returns a Time' do
-        expect(result.value).to eql Time.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 an Integer' do
-      let(:value) { rand(1 << 16) }
-
-      it 'returns the Time' do
-        expect(result.value).to eql Time.at(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 the Time' do
-        expect(result.value).to eql Time.at(value)
-      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 Time' do
-        expect(
-          result.value
-        ).to eql Time.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/grouped_input_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe ActiveInteraction::GroupedInput do
-  subject(:grouped_input) { described_class.new }
-
-  it 'subclasses OpenStruct' do
-    expect(grouped_input).to be_an OpenStruct
-  end
-
-  it 'responds to #[]' do
-    expect { grouped_input[:key] }.to_not raise_error
-  end
-
-  it 'responds to #[]=' do
-    expect { grouped_input[:key] = :value }.to_not raise_error
-  end
-end

data/spec/active_interaction/hash_input_spec.rb

@@ -1,56 +0,0 @@
-RSpec.describe ActiveInteraction::HashInput do
-  subject(:input) do
-    described_class.new(filter,
-      value: value,
-      error: error,
-      children: children
-    )
-  end
-
-  let(:filter) do
-    ActiveInteraction::HashFilter.new(:h, &block)
-  end
-  let(:block) { proc { integer :i } }
-  let(:value) { nil }
-  let(:error) { nil }
-  let(:children) { {} }
-
-  describe '#errors' do
-    context 'with no errors' do
-      it 'returns an empty array' do
-        expect(input.errors).to be_empty
-      end
-    end
-
-    context 'with an error on the hash' do
-      let(:error) { ActiveInteraction::Filter::Error.new(filter, :invalid_type) }
-
-      it 'returns one error in the array' do
-        expect(input.errors.size).to be 1
-
-        error = input.errors.first
-        expect(error.name).to be filter.name
-        expect(error.type).to be :invalid_type
-      end
-    end
-
-    context 'with children with errors' do
-      let(:child_i) do
-        filter = ActiveInteraction::IntegerFilter.new(:i)
-        ActiveInteraction::Input.new(filter,
-          value: nil,
-          error: ActiveInteraction::Filter::Error.new(filter, :missing)
-        )
-      end
-      let(:children) { { i: child_i } }
-
-      it 'returns the error' do
-        expect(input.errors.size).to be 1
-
-        error = input.errors.first
-        expect(error.name).to be :"#{filter.name}.i"
-        expect(error.type).to be :missing
-      end
-    end
-  end
-end