active_interaction 4.1.0 → 5.1.1

data/spec/active_interaction/filters/record_filter_spec.rb

@@ -14,11 +14,7 @@ class RecordThing
   end
 
   def self.finds_bad_value(_)
-    ''
-  end
-
-  def self.passthrough(obj)
-    obj
+    Object.new
   end
 end
 
@@ -27,23 +23,19 @@ BackupRecordThing = RecordThing
 
 describe ActiveInteraction::RecordFilter, :filter do
   include_context 'filters'
-  it_behaves_like 'a filter'
-
   before do
     options[:class] = RecordThing
   end
 
-  describe '#cast' do
-    before do
-      options[:finder] = :finder
-    end
+  it_behaves_like 'a filter'
 
+  describe '#process' do
     let(:value) { RecordThing.new }
-    let(:result) { filter.send(:cast, value, nil) }
+    let(:result) { filter.process(value, nil) }
 
     context 'with an instance of the class' do
       it 'returns the instance' do
-        expect(result).to eql value
+        expect(result.value).to eql value
       end
 
       context 'with an instance that is a subclass' do
@@ -51,18 +43,18 @@ describe ActiveInteraction::RecordFilter, :filter do
         let(:value) { subclass.new }
 
         it 'returns the instance' do
-          expect(result).to eql value
+          expect(result.value).to eql value
         end
       end
 
       it 'handles reconstantizing' do
-        expect(result).to eql value
+        expect(result.value).to eql value
 
         Object.send(:remove_const, :RecordThing)
         RecordThing = BackupRecordThing # rubocop:disable Lint/ConstantDefinitionInBlock
         value = RecordThing.new
 
-        expect(filter.send(:cast, value, nil)).to eql value
+        expect(filter.process(value, nil).value).to eql value
       end
 
       it 'handles reconstantizing subclasses' do
@@ -73,11 +65,12 @@ describe ActiveInteraction::RecordFilter, :filter do
         class SubRecordThing < RecordThing; end # rubocop:disable Lint/ConstantDefinitionInBlock
         value = SubRecordThing.new
 
-        expect(filter.send(:cast, value, nil)).to eql value
+        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
@@ -92,7 +85,7 @@ describe ActiveInteraction::RecordFilter, :filter do
       end
 
       it 'returns the instance' do
-        expect(result).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -102,7 +95,7 @@ describe ActiveInteraction::RecordFilter, :filter do
       end
 
       it 'returns the instance' do
-        expect(result).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -112,7 +105,7 @@ describe ActiveInteraction::RecordFilter, :filter do
       before { options[:class] = RecordThings }
 
       it 'returns the instance' do
-        expect(result).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -129,48 +122,77 @@ describe ActiveInteraction::RecordFilter, :filter do
     end
 
     context 'with a value that does not match the class' do
-      let(:value) { '' }
+      let(:value) { 1 }
 
-      it 'calls the finder' do
-        expect(result).to eql RecordThing.finder(value)
+      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
-          expect(result).to eql RecordThing.finder(value)
+          allow(RecordThing).to receive(:finder)
+          result
+          expect(RecordThing).to have_received(:finder).with(value)
         end
       end
-    end
-  end
 
-  describe '#clean' do
-    context 'with a value that does not match the class' do
       context 'that returns a nil' do
-        let(:value) { '' }
+        let(:value) { 1 }
 
         before do
           options[:default] = RecordThing.new
           options[:finder] = :finds_nil
         end
 
-        it 'raises an error' do
-          expect do
-            filter.clean(value, nil)
-          end.to raise_error ActiveInteraction::InvalidValueError
+        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) { '' }
+        let(:value) { 1 }
 
         before do
           options[:finder] = :finds_bad_value
         end
 
-        it 'raises an error' do
-          expect do
-            filter.clean(value, nil)
-          end.to raise_error ActiveInteraction::InvalidValueError
+        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
@@ -178,7 +200,7 @@ describe ActiveInteraction::RecordFilter, :filter do
 
   describe '#database_column_type' do
     it 'returns :string' do
-      expect(filter.database_column_type).to eql :string
+      expect(filter.database_column_type).to be :string
     end
   end
 end

data/spec/active_interaction/filters/string_filter_spec.rb

@@ -10,14 +10,14 @@ describe ActiveInteraction::StringFilter, :filter do
     end
   end
 
-  describe '#cast' do
-    let(:result) { filter.send(:cast, value, nil) }
+  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).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -31,7 +31,7 @@ describe ActiveInteraction::StringFilter, :filter do
       end
 
       it 'returns the String' do
-        expect(result).to eql value.to_str
+        expect(result.value).to eql value.to_str
       end
     end
 
@@ -39,14 +39,14 @@ describe ActiveInteraction::StringFilter, :filter do
       let(:value) { " #{SecureRandom.hex} " }
 
       it 'returns the stripped string' do
-        expect(result).to eql value.strip
+        expect(result.value).to eql value.strip
       end
 
       context 'without strip' do
         include_context 'without strip'
 
         it 'returns the String' do
-          expect(result).to eql value
+          expect(result.value).to eql value
         end
       end
     end
@@ -54,7 +54,7 @@ describe ActiveInteraction::StringFilter, :filter do
 
   describe '#database_column_type' do
     it 'returns :string' do
-      expect(filter.database_column_type).to eql :string
+      expect(filter.database_column_type).to be :string
     end
   end
 end

data/spec/active_interaction/filters/symbol_filter_spec.rb

@@ -4,14 +4,14 @@ describe ActiveInteraction::SymbolFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '#cast' do
-    let(:result) { filter.send(:cast, value, nil) }
+  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).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -25,7 +25,7 @@ describe ActiveInteraction::SymbolFilter, :filter do
       end
 
       it 'returns a symbol' do
-        expect(result).to eql value.to_sym
+        expect(result.value).to eql value.to_sym
       end
     end
 
@@ -33,14 +33,14 @@ describe ActiveInteraction::SymbolFilter, :filter do
       let(:value) { SecureRandom.hex }
 
       it 'returns a Symbol' do
-        expect(result).to eql value.to_sym
+        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 eql :string
+      expect(filter.database_column_type).to be :string
     end
   end
 end

data/spec/active_interaction/filters/time_filter_spec.rb

@@ -18,11 +18,12 @@ describe ActiveInteraction::TimeFilter, :filter do
 
       context 'with a time zone' do
         before do
-          time_zone = double
-          allow(Time).to receive(:zone).and_return(time_zone)
-
           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
@@ -34,14 +35,14 @@ describe ActiveInteraction::TimeFilter, :filter do
     end
   end
 
-  describe '#cast' do
-    let(:result) { filter.send(:cast, value, nil) }
+  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).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -49,7 +50,24 @@ describe ActiveInteraction::TimeFilter, :filter do
       let(:value) { '2011-12-13 14:15:16 +1718' }
 
       it 'returns a Time' do
-        expect(result).to eql Time.parse(value)
+        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
@@ -58,7 +76,7 @@ describe ActiveInteraction::TimeFilter, :filter do
         let(:value) { '13/12/2011 14:15:16 +1718' }
 
         it 'returns a Time' do
-          expect(result).to eql Time.strptime(value, format)
+          expect(result.value).to eql Time.strptime(value, format)
         end
       end
     end
@@ -66,19 +84,21 @@ describe ActiveInteraction::TimeFilter, :filter do
     context 'with an invalid String' do
       let(:value) { 'invalid' }
 
-      it 'raises an error' do
-        expect do
-          result
-        end.to raise_error ActiveInteraction::InvalidValueError
+      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 do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidValueError
+        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
@@ -93,7 +113,7 @@ describe ActiveInteraction::TimeFilter, :filter do
       end
 
       it 'returns a Time' do
-        expect(result).to eql Time.parse(value)
+        expect(result.value).to eql Time.parse(value)
       end
     end
 
@@ -110,17 +130,18 @@ describe ActiveInteraction::TimeFilter, :filter do
         include_context 'optional'
 
         it 'returns the default' do
-          expect(result).to eql options[:default]
+          expect(result.value).to eql options[:default]
         end
       end
 
       context 'required' do
         include_context 'required'
 
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::MissingValueError
+        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
@@ -129,7 +150,7 @@ describe ActiveInteraction::TimeFilter, :filter do
       let(:value) { rand(1 << 16) }
 
       it 'returns the Time' do
-        expect(result).to eql Time.at(value)
+        expect(result.value).to eql Time.at(value)
       end
     end
 
@@ -143,7 +164,7 @@ describe ActiveInteraction::TimeFilter, :filter do
       end
 
       it 'returns the Time' do
-        expect(result).to eql Time.at(value)
+        expect(result.value).to eql Time.at(value)
       end
     end
 
@@ -167,7 +188,7 @@ describe ActiveInteraction::TimeFilter, :filter do
 
       it 'returns a Time' do
         expect(
-          result
+          result.value
         ).to eql Time.new(year, month, day, hour, min, sec)
       end
     end
@@ -176,10 +197,11 @@ describe ActiveInteraction::TimeFilter, :filter do
       context 'empty' do
         let(:value) { ActiveInteraction::GroupedInput.new }
 
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidValueError
+        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
 
@@ -190,10 +212,11 @@ describe ActiveInteraction::TimeFilter, :filter do
           )
         end
 
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidValueError
+        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
@@ -201,7 +224,7 @@ describe ActiveInteraction::TimeFilter, :filter do
 
   describe '#database_column_type' do
     it 'returns :datetime' do
-      expect(filter.database_column_type).to eql :datetime
+      expect(filter.database_column_type).to be :datetime
     end
   end
 

data/spec/active_interaction/hash_input_spec.rb

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

data/spec/active_interaction/i18n_spec.rb

@@ -15,20 +15,23 @@ I18nInteraction = Class.new(TestInteraction) do
   end
 end
 
+TYPES = ActiveInteraction::Filter
+  .const_get(:CLASSES)
+  .keys
+  .map(&:to_s)
+
 describe I18nInteraction do
   include_context 'interactions'
 
-  TYPES = ActiveInteraction::Filter # rubocop:disable Lint/ConstantDefinitionInBlock
-    .const_get(:CLASSES)
-    .map { |slug, _| slug.to_s }
-
   shared_examples 'translation' do |locale|
-    before do
-      @locale = I18n.locale
+    around do |example|
+      old_locale = I18n.locale
       I18n.locale = locale
-    end
 
-    after { I18n.locale = @locale }
+      example.run
+
+      I18n.locale = old_locale
+    end
 
     context 'types' do
       TYPES.each do |type|
@@ -81,16 +84,12 @@ describe I18nInteraction do
   end
 
   context 'hsilgne' do
-    before do
-      # This must appear before including the translation examples so that the
-      # locale is available before it is assigned.
-      locale = :hsilgne
-      I18n.config.available_locales = I18n.config.available_locales + [locale] unless I18n.locale_available?(locale)
-    end
+    # This must appear before including the translation examples so that the
+    # locale is available before it is assigned.
+    around do |example|
+      old_locals = I18n.config.available_locales
+      I18n.config.available_locales += [:hsilgne]
 
-    include_examples 'translation', :hsilgne
-
-    before do
       I18n.backend.store_translations('hsilgne',
         active_interaction: {
           errors: {
@@ -103,6 +102,12 @@ describe I18nInteraction do
           types: TYPES.each_with_object({}) { |e, a| a[e] = e.reverse }
         }
       )
+
+      example.run
+
+      I18n.config.available_locales = old_locals
     end
+
+    include_examples 'translation', :hsilgne
   end
 end