active_interaction 4.1.0 → 5.0.0

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

data/spec/active_interaction/inputs_spec.rb

@@ -1,11 +1,14 @@
 require 'spec_helper'
 
 describe ActiveInteraction::Inputs do
-  subject(:inputs) { described_class.new }
+  subject(:inputs) { described_class.new(args, base_class.new) }
+
+  let(:args) { {} }
+  let(:base_class) { ActiveInteraction::Base }
 
   describe '.reserved?(name)' do
     it 'returns true for anything starting with "_interaction_"' do
-      expect(described_class.reserved?('_interaction_')).to be_truthy
+      expect(described_class).to be_reserved('_interaction_')
     end
 
     it 'returns true for existing instance methods' do
@@ -13,21 +16,20 @@ describe ActiveInteraction::Inputs do
         (ActiveInteraction::Base.instance_methods - Object.instance_methods) +
         (ActiveInteraction::Base.private_instance_methods - Object.private_instance_methods)
       ).each do |method|
-        expect(described_class.reserved?(method)).to be_truthy
+        expect(described_class).to be_reserved(method)
       end
     end
 
     it 'returns false for anything else' do
-      expect(described_class.reserved?(SecureRandom.hex)).to be_falsey
+      expect(described_class).to_not be_reserved(SecureRandom.hex)
     end
   end
 
-  describe '.process(inputs)' do
-    let(:inputs) { {} }
-    let(:result) { described_class.process(inputs) }
+  describe '#normalized' do
+    let(:result) { inputs.normalized }
 
     context 'with invalid inputs' do
-      let(:inputs) { nil }
+      let(:args) { nil }
 
       it 'raises an error' do
         expect { result }.to raise_error ArgumentError
@@ -35,7 +37,7 @@ describe ActiveInteraction::Inputs do
     end
 
     context 'with non-hash inputs' do
-      let(:inputs) { [%i[k v]] }
+      let(:args) { [%i[k v]] }
 
       it 'raises an error' do
         expect { result }.to raise_error ArgumentError
@@ -43,15 +45,7 @@ describe ActiveInteraction::Inputs do
     end
 
     context 'with ActionController::Parameters inputs' do
-      let(:inputs) { ActionController::Parameters.new }
-
-      it 'does not raise an error' do
-        expect { result }.to_not raise_error
-      end
-    end
-
-    context 'with Inputs inputs' do
-      let(:inputs) { ActiveInteraction::Inputs.new }
+      let(:args) { ::ActionController::Parameters.new }
 
       it 'does not raise an error' do
         expect { result }.to_not raise_error
@@ -59,17 +53,17 @@ describe ActiveInteraction::Inputs do
     end
 
     context 'with simple inputs' do
-      before { inputs[:key] = :value }
+      before { args[:key] = :value }
 
       it 'sends them straight through' do
-        expect(result).to eql inputs
+        expect(result).to eql args
       end
     end
 
     context 'with groupable inputs' do
       context 'without a matching simple input' do
         before do
-          inputs.merge!(
+          args.merge!(
             'key(1i)' => :value1,
             'key(2i)' => :value2
           )
@@ -87,7 +81,7 @@ describe ActiveInteraction::Inputs do
 
       context 'with a matching simple input' do
         before do
-          inputs.merge!(
+          args.merge!(
             'key(1i)' => :value1,
             key: :value2
           )
@@ -104,11 +98,161 @@ describe ActiveInteraction::Inputs do
     end
 
     context 'with a reserved name' do
-      before { inputs[:_interaction_key] = :value }
+      before { args[:_interaction_key] = :value }
 
       it 'skips the input' do
         expect(result).to_not have_key(:_interaction_key)
       end
     end
   end
+
+  describe '#given?' do
+    let(:base_class) do
+      Class.new(ActiveInteraction::Base) do
+        float :x,
+          default: nil
+
+        def execute; end
+      end
+    end
+
+    it 'is false when the input is not given' do
+      expect(inputs.given?(:x)).to be false
+    end
+
+    it 'is true when the input is nil' do
+      args[:x] = nil
+      expect(inputs.given?(:x)).to be true
+    end
+
+    it 'is true when the input is given' do
+      args[:x] = rand
+      expect(inputs.given?(:x)).to be true
+    end
+
+    it 'symbolizes its argument' do
+      args[:x] = rand
+      expect(inputs.given?('x')).to be true
+    end
+
+    it 'only tracks inputs with filters' do
+      args[:y] = rand
+      expect(inputs.given?(:y)).to be false
+    end
+
+    context 'nested hash values' do
+      let(:base_class) do
+        Class.new(ActiveInteraction::Base) do
+          hash :x, default: {} do
+            boolean :y,
+              default: true
+          end
+
+          def execute; end
+        end
+      end
+
+      it 'is true when the nested inputs symbols are given' do
+        described_class.class_exec do
+          def execute
+            given?(:x, :y)
+          end
+        end
+
+        args[:x] = { y: false }
+        expect(inputs.given?(:x, :y)).to be true
+      end
+
+      it 'is true when the nested inputs strings are given' do
+        args['x'] = { 'y' => false }
+        expect(inputs.given?(:x, :y)).to be true
+      end
+
+      it 'is false when the nested input is not given' do
+        args[:x] = {}
+        expect(inputs.given?(:x, :y)).to be false
+      end
+
+      it 'is false when the first input is not given' do
+        expect(inputs.given?(:x, :y)).to be false
+      end
+
+      it 'is false when the first input is nil' do
+        args[:x] = nil
+        expect(inputs.given?(:x, :y)).to be false
+      end
+
+      it 'returns false if you go too far' do
+        args[:x] = { y: true }
+        expect(inputs.given?(:x, :y, :z)).to be false
+      end
+    end
+
+    context 'nested array values' do
+      let(:base_class) do
+        Class.new(ActiveInteraction::Base) do
+          array :x do
+            hash do
+              boolean :y, default: true
+            end
+          end
+
+          def execute; end
+        end
+      end
+
+      context 'has a positive index' do
+        it 'returns true if found' do
+          args[:x] = [{ y: true }]
+          expect(inputs.given?(:x, 0, :y)).to be true
+        end
+
+        it 'returns false if not found' do
+          args[:x] = []
+          expect(inputs.given?(:x, 0, :y)).to be false
+        end
+      end
+
+      context 'has a negative index' do
+        it 'returns true if found' do
+          args[:x] = [{ y: true }]
+          expect(inputs.given?(:x, -1, :y)).to be true
+        end
+
+        it 'returns false if not found' do
+          args[:x] = []
+          expect(inputs.given?(:x, -1, :y)).to be false
+        end
+      end
+
+      it 'returns false if you go too far' do
+        args[:x] = [{}]
+        expect(inputs.given?(:x, 10, :y)).to be false
+      end
+    end
+
+    context 'multi-part date values' do
+      let(:base_class) do
+        Class.new(ActiveInteraction::Base) do
+          date :thing,
+            default: nil
+
+          def execute; end
+        end
+      end
+
+      it 'returns true when the input is given' do
+        args.merge!(
+          'thing(1i)' => '2020',
+          'thing(2i)' => '12',
+          'thing(3i)' => '31'
+        )
+        expect(inputs.given?(:thing)).to be true
+      end
+
+      it 'returns false if not found' do
+        expect(inputs.given?(:thing)).to be false
+      end
+    end
+  end
 end

data/spec/active_interaction/integration/array_interaction_spec.rb

@@ -1,10 +1,6 @@
 require 'spec_helper'
 require 'active_record'
-if defined?(JRUBY_VERSION)
-  require 'activerecord-jdbcsqlite3-adapter'
-else
-  require 'sqlite3'
-end
+require 'sqlite3'
 
 ActiveRecord::Base.establish_connection(
   adapter: 'sqlite3',
@@ -36,8 +32,8 @@ end
 describe ArrayInteraction do
   include_context 'interactions'
   it_behaves_like 'an interaction', :array, -> { [] }
-  it_behaves_like 'an interaction', :array, -> { Element.where('1 = 1') }
-  it_behaves_like 'an interaction', :array, -> { List.create!.elements }
+  it_behaves_like 'an interaction', :array, -> { Element.where('1 = 1') }, ->(result) { result.to_a }
+  it_behaves_like 'an interaction', :array, -> { List.create!.elements }, ->(result) { result.to_a }
 
   context 'with inputs[:a]' do
     let(:a) { [[]] }

data/spec/active_interaction/modules/validation_spec.rb

@@ -22,11 +22,11 @@ describe ActiveInteraction::Validation do
       end
     end
 
-    context 'filter.cast returns a value' do
+    context 'filter returns no errors' do
       let(:inputs) { { name: 1 } }
 
       before do
-        allow(filter).to receive(:cast).and_return(1)
+        allow(filter).to receive(:process).and_return(ActiveInteraction::Input.new(filter, value: 1))
       end
 
       it 'returns no errors' do
@@ -34,14 +34,15 @@ describe ActiveInteraction::Validation do
       end
     end
 
-    context 'filter throws' do
+    context 'filter returns with errors' do
       before do
-        allow(filter).to receive(:cast).and_raise(exception)
+        allow(filter).to receive(:process).and_return(ActiveInteraction::Input.new(filter, error: exception))
       end
 
-      context 'InvalidValueError' do
-        let(:exception) { ActiveInteraction::InvalidValueError }
-        let(:filter) { ActiveInteraction::FloatFilter.new(:name, {}) }
+      context 'Filter::Error' do
+        let(:filter) { ActiveInteraction::ArrayFilter.new(:name, [1.0, 'a']) { float } }
+
+        let(:exception) { ActiveInteraction::Filter::Error.new(filter, :invalid_type) }
 
         it 'returns an :invalid_type error' do
           type = I18n.translate(
@@ -51,30 +52,6 @@ describe ActiveInteraction::Validation do
           expect(result).to eql [[filter.name, :invalid_type, { type: type }]]
         end
       end
-
-      context 'MissingValueError' do
-        let(:exception) { ActiveInteraction::MissingValueError }
-
-        it 'returns a :missing error' do
-          expect(result).to eql [[filter.name, :missing]]
-        end
-      end
-
-      context 'InvalidNestedValueError' do
-        let(:exception) do
-          ActiveInteraction::InvalidNestedValueError.new(name, value)
-        end
-        let(:name) { SecureRandom.hex.to_sym }
-        let(:value) { double }
-
-        it 'returns an :invalid_nested error' do
-          expect(result).to eql [[
-            filter.name,
-            :invalid_nested,
-            { name: name.inspect, value: value.inspect }
-          ]]
-        end
-      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -8,4 +8,12 @@ Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run_including :focus
+
+  config.before(:suite) do
+    if ::ActiveRecord.respond_to?(:index_nested_attribute_errors)
+      ::ActiveRecord.index_nested_attribute_errors = false
+    else
+      ::ActiveRecord::Base.index_nested_attribute_errors = false
+    end
+  end
 end

data/spec/support/concerns.rb

@@ -1,4 +1,6 @@
 shared_context 'concerns' do |concern|
+  subject(:instance) { klass.new }
+
   let(:klass) do
     Class.new do
       include concern
@@ -8,6 +10,4 @@ shared_context 'concerns' do |concern|
       end
     end
   end
-
-  subject(:instance) { klass.new }
 end