active_interaction 4.1.0 → 5.1.1

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,23 +37,23 @@ 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
       end
     end
 
-    context 'with ActionController::Parameters inputs' do
-      let(:inputs) { ActionController::Parameters.new }
+    context 'with ActiveInteraction::Inputs inputs' do
+      let(:args) { described_class.new({ key: :value }, base_class.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 }
+    context 'with ActionController::Parameters inputs' do
+      let(:args) { ::ActionController::Parameters.new }
 
       it 'does not raise an error' do
         expect { result }.to_not raise_error
@@ -59,17 +61,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 +89,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 +106,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/integration/record_integration_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'RecordIntegration' do
+  it_behaves_like 'an interaction', :record, -> { Encoding::US_ASCII }, class: Encoding
+end

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

@@ -2,10 +2,19 @@ require 'i18n'
 I18n.config.enforce_available_locales = true if I18n.config.respond_to?(:enforce_available_locales)
 
 require 'active_interaction'
+require 'active_record'
 
 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

data/spec/support/filters.rb

@@ -1,10 +1,10 @@
 shared_context 'filters' do
+  subject(:filter) { described_class.new(name, options, &block) }
+
   let(:block) { nil }
   let(:name) { SecureRandom.hex.to_sym }
   let(:options) { {} }
 
-  subject(:filter) { described_class.new(name, options, &block) }
-
   shared_context 'optional' do
     before do
       options[:default] = nil
@@ -45,71 +45,35 @@ shared_examples_for 'a filter' do
     end
   end
 
-  describe '#cast' do
-    let(:value) { nil }
-    let(:result) { filter.send(:cast, value, nil) }
-
-    context 'optional' do
-      include_context 'optional'
-
-      it 'returns nil' do
-        expect(result).to be_nil
-      end
-    end
-
-    context 'required' do
-      include_context 'required'
-
-      it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::MissingValueError
-      end
-
-      context 'with an invalid default' do
-        let(:value) { Object.new }
-
-        it 'raises an error' do
-          expect { result }.to raise_error ActiveInteraction::InvalidValueError
-        end
-      end
-    end
-
-    # BasicObject is missing a lot of methods
-    context 'with a BasicObject' do
-      let(:value) { BasicObject.new }
-
-      it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::InvalidValueError
-      end
-    end
-  end
-
-  describe '#clean' do
+  describe '#process' do
     let(:value) { nil }
 
     context 'optional' do
       include_context 'optional'
 
       it 'returns the default' do
-        expect(filter.clean(value, nil)).to eql options[:default]
+        expect(filter.process(value, nil).value).to eql options[:default]
       end
     end
 
     context 'required' do
       include_context 'required'
 
-      it 'raises an error' do
-        expect do
-          filter.clean(value, nil)
-        end.to raise_error ActiveInteraction::MissingValueError
+      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
 
       context 'with an invalid value' do
         let(:value) { Object.new }
 
-        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
@@ -121,10 +85,22 @@ shared_examples_for 'a filter' do
 
       it 'raises an error' do
         expect do
-          filter.clean(value, nil)
+          filter.process(value, nil)
         end.to raise_error ActiveInteraction::InvalidDefaultError
       end
     end
+
+    # BasicObject is missing a lot of methods
+    context 'with a BasicObject' do
+      let(:value) { BasicObject.new }
+
+      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
 
   describe '#default' do

data/spec/support/interactions.rb

@@ -14,7 +14,7 @@ shared_context 'interactions' do
   let(:result) { outcome.result }
 end
 
-shared_examples_for 'an interaction' do |type, generator, filter_options = {}|
+shared_examples_for 'an interaction' do |type, generator, adjust_output = nil, **filter_options|
   include_context 'interactions'
 
   let(:described_class) do
@@ -73,7 +73,7 @@ shared_examples_for 'an interaction' do |type, generator, filter_options = {}|
     end
 
     it 'returns the correct value for :required' do
-      expect(result[:required]).to eql required
+      expect(result[:required]).to eql(adjust_output ? adjust_output.call(required) : required)
     end
 
     it 'returns nil for :optional' do
@@ -107,7 +107,7 @@ shared_examples_for 'an interaction' do |type, generator, filter_options = {}|
       before { inputs[:optional] = optional }
 
       it 'returns the correct value for :optional' do
-        expect(result[:optional]).to eql optional
+        expect(result[:optional]).to eql(adjust_output ? adjust_output.call(optional) : optional)
       end
     end
 
@@ -117,7 +117,7 @@ shared_examples_for 'an interaction' do |type, generator, filter_options = {}|
       before { inputs[:default] = default }
 
       it 'returns the correct value for :default' do
-        expect(result[:default]).to eql default
+        expect(result[:default]).to eql(adjust_output ? adjust_output.call(default) : default)
       end
     end
   end