active_interaction 4.1.0 → 5.0.0

data/spec/active_interaction/concerns/runnable_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveInteraction::Runnable do
-  include_context 'concerns', ActiveInteraction::Runnable
+  include_context 'concerns', described_class
 
   class WrappableFailingInteraction # rubocop:disable Lint/ConstantDefinitionInBlock
     include ActiveInteraction::Runnable
@@ -230,49 +230,51 @@ describe ActiveInteraction::Runnable do
       end
     end
 
-    context 'caches the validity and result of the run' do
-      let(:klass) do
-        Class.new(ActiveInteraction::Base) do
-          invalid = [false, true].cycle
+    context 'caches the result of the run' do
+      context 'when it is invalid' do
+        let(:klass) do
+          Class.new(ActiveInteraction::Base) do
+            invalid = [false, true].cycle
 
-          validate do |interaction|
-            interaction.errors.add(:base, 'failed') unless invalid.next
-          end
+            validate do |interaction|
+              interaction.errors.add(:base, 'failed') unless invalid.next
+            end
 
-          def execute
-            true
+            def execute
+              true
+            end
           end
         end
-      end
 
-      it 'is invalid' do
-        expect(outcome).to_not be_valid
-        expect(outcome.result).to be_nil
-        expect(outcome).to_not be_valid
-        expect(outcome.result).to be_nil
+        it 'fails' do
+          expect(outcome).to_not be_valid
+          expect(outcome.result).to be_nil
+          expect(outcome).to_not be_valid
+          expect(outcome.result).to be_nil
+        end
       end
-    end
 
-    context 'caches the validity and result of the run' do
-      let(:klass) do
-        Class.new(ActiveInteraction::Base) do
-          valid = [true, false].cycle
+      context 'when it is valid' do
+        let(:klass) do
+          Class.new(ActiveInteraction::Base) do
+            valid = [true, false].cycle
 
-          validate do |interaction|
-            interaction.errors.add(:base, 'failed') unless valid.next
-          end
+            validate do |interaction|
+              interaction.errors.add(:base, 'failed') unless valid.next
+            end
 
-          def execute
-            true
+            def execute
+              true
+            end
           end
         end
-      end
 
-      it 'is valid' do
-        expect(outcome).to be_valid
-        expect(outcome.result).to be true
-        expect(outcome).to be_valid
-        expect(outcome.result).to be true
+        it 'succeeds' do
+          expect(outcome).to be_valid
+          expect(outcome.result).to be true
+          expect(outcome).to be_valid
+          expect(outcome.result).to be true
+        end
       end
     end
 

data/spec/active_interaction/errors_spec.rb

@@ -1,22 +1,19 @@
 require 'spec_helper'
 require 'active_record'
-unless defined?(JRUBY_VERSION) # rubocop:disable Style/IfUnlessModifier
-  require 'sqlite3'
-end
+require 'sqlite3'
 
-unless defined?(JRUBY_VERSION)
-  ActiveRecord::Base.establish_connection(
-    adapter: 'sqlite3',
-    database: ':memory:'
-  )
-end
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
 
 describe ActiveInteraction::Errors do
-  let(:klass) do
-    Class.new do
-      include ActiveInteraction::ActiveModelable
+  subject(:errors) { described_class.new(klass.new) }
 
-      attr_reader :attribute
+  let(:klass) do
+    Class.new(ActiveInteraction::Base) do
+      string :attribute, defualt: nil
+      array :array, defualt: nil
 
       def self.name
         @name ||= SecureRandom.hex
@@ -24,8 +21,6 @@ describe ActiveInteraction::Errors do
     end
   end
 
-  subject(:errors) { described_class.new(klass.new) }
-
   describe '#merge!' do
     let(:other) { described_class.new(klass.new) }
 
@@ -124,6 +119,25 @@ describe ActiveInteraction::Errors do
       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) }
 
@@ -139,40 +153,43 @@ describe ActiveInteraction::Errors do
       end
     end
 
-    unless defined?(JRUBY_VERSION)
-      context 'with nested errors' do
-        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
-
-          class A < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
-            has_one :b
-            accepts_nested_attributes_for :b
-          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
 
-          class B < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
-            belongs_to :a
+          validates :name, presence: true
+        end
+      end
 
-            validates :name, presence: true
+      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
 
-        let(:a) { A.create(b_attributes: { name: nil }) }
+        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 eql 1
-          expect { errors.merge!(a.errors) }.to_not raise_error
-          expect(errors.size).to eql 1
-        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

data/spec/active_interaction/{filter_column_spec.rb → filter/column_spec.rb}

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
-describe ActiveInteraction::FilterColumn do
-  let(:type) { :float }
+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
@@ -83,12 +84,4 @@ describe ActiveInteraction::FilterColumn do
       end
     end
   end
-
-  describe '#type' do
-    let(:type) { :float }
-
-    it 'returns the type' do
-      expect(column.type).to eql type
-    end
-  end
 end

data/spec/active_interaction/filter_spec.rb

@@ -5,30 +5,30 @@ describe ActiveInteraction::Filter, :filter do
 
   describe '#database_column_type' do
     it 'returns `:string`' do
-      expect(subject.database_column_type).to eql :string
+      expect(filter.database_column_type).to be :string
     end
   end
 
   context 'with an unregistered subclass' do
-    let(:described_class) { Class.new(ActiveInteraction::Filter) }
+    let(:klass) { Class.new(described_class) }
 
     describe '.slug' do
       it 'is nil' do
-        expect(described_class.slug).to be_nil
+        expect(klass.slug).to be_nil
       end
     end
   end
 
   context 'with a registered subclass' do
-    it_behaves_like 'a filter'
-
+    let(:slug) { SecureRandom.hex.to_sym }
     let(:described_class) do
       s = slug
       Class.new(ActiveInteraction::Filter) do
         register s
       end
     end
-    let(:slug) { SecureRandom.hex.to_sym }
+
+    it_behaves_like 'a filter'
 
     describe '.slug' do
       it 'returns the registered slug' do

data/spec/active_interaction/filters/abstract_date_time_filter_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe ActiveInteraction::AbstractDateTimeFilter, :filter do
   include_context 'filters'
 
-  describe '#cast' do
+  describe '#process' do
     let(:value) { nil }
 
     it 'raises an error' do
-      expect { filter.send(:cast, value, nil) }.to raise_error NameError
+      expect { filter.process(value, nil) }.to raise_error NameError
     end
   end
 end

data/spec/active_interaction/filters/abstract_numeric_filter_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe ActiveInteraction::AbstractNumericFilter, :filter do
   include_context 'filters'
 
-  describe '#cast' do
+  describe '#process' do
     let(:value) { nil }
 
     it 'raises an error' do
-      expect { filter.send(:cast, value, nil) }.to raise_error NameError
+      expect { filter.process(value, nil) }.to raise_error NameError
     end
   end
 end

data/spec/active_interaction/filters/array_filter_spec.rb

@@ -25,14 +25,22 @@ describe ActiveInteraction::ArrayFilter, :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 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).to eql value
+        expect(result.value).to eql value
+      end
+
+      it 'has no children' do
+        expect(result.children).to eql []
       end
     end
 
@@ -46,7 +54,7 @@ describe ActiveInteraction::ArrayFilter, :filter do
       end
 
       it 'returns the Array' do
-        expect(result).to eql value.to_ary
+        expect(result.value).to eql value.to_ary
       end
     end
 
@@ -54,7 +62,7 @@ describe ActiveInteraction::ArrayFilter, :filter do
       let(:value) { [[], false, 0.0, {}, 0, '', :''] }
 
       it 'returns the Array' do
-        expect(result).to eql value
+        expect(result.value).to eql value
       end
     end
 
@@ -62,10 +70,31 @@ describe ActiveInteraction::ArrayFilter, :filter do
       let(:block) { proc { array } }
 
       context 'with an Array' do
-        let(:value) { [] }
+        let(:child_value) { [] }
+        let(:value) { [child_value, child_value] }
 
         it 'returns the Array' do
-          expect(result).to eql value
+          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 be 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
 
@@ -73,17 +102,71 @@ describe ActiveInteraction::ArrayFilter, :filter do
         let(:value) { [[]] }
 
         it 'returns the Array' do
-          expect(result).to eql value
+          expect(result.value).to eql value
         end
       end
 
       context 'with a heterogenous Array' do
-        let(:value) { [[], false, 0.0, {}, 0, '', :''] }
+        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
 
-        it 'raises an error' do
-          expect do
-            result
-          end.to raise_error ActiveInteraction::InvalidValueError
+        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
@@ -136,9 +219,9 @@ describe ActiveInteraction::ArrayFilter, :filter do
 
         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 eql :Object
+          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 eql :new
+          expect(filter.filters[:'0'].options[:converter]).to be :new
         end
       end
     end
@@ -146,7 +229,7 @@ describe ActiveInteraction::ArrayFilter, :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/boolean_filter_spec.rb

@@ -4,11 +4,11 @@ describe ActiveInteraction::BooleanFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '#cast' do
+  describe '#process' do
     context 'falsey' do
       [false, '0', 'false', 'FALSE', 'off', 'OFF'].each do |value|
         it "returns false for #{value.inspect}" do
-          expect(filter.send(:cast, value, nil)).to be_falsey
+          expect(filter.process(value, nil).value).to be_falsey
         end
       end
 
@@ -22,7 +22,7 @@ describe ActiveInteraction::BooleanFilter, :filter do
         end
 
         it 'returns false' do
-          expect(filter.send(:cast, value, nil)).to be_falsey
+          expect(filter.process(value, nil).value).to be_falsey
         end
       end
     end
@@ -30,7 +30,7 @@ describe ActiveInteraction::BooleanFilter, :filter do
     context 'truthy' do
       [true, '1', 'true', 'TRUE', 'on', 'ON'].each do |value|
         it "returns true for #{value.inspect}" do
-          expect(filter.send(:cast, value, nil)).to be_truthy
+          expect(filter.process(value, nil).value).to be_truthy
         end
       end
 
@@ -44,7 +44,7 @@ describe ActiveInteraction::BooleanFilter, :filter do
         end
 
         it 'returns true' do
-          expect(filter.send(:cast, value, nil)).to be_truthy
+          expect(filter.process(value, nil).value).to be_truthy
         end
       end
     end
@@ -62,17 +62,18 @@ describe ActiveInteraction::BooleanFilter, :filter do
         include_context 'optional'
 
         it 'returns the default' do
-          expect(filter.send(:cast, 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.send(:cast, 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
       end
     end
@@ -80,7 +81,7 @@ describe ActiveInteraction::BooleanFilter, :filter do
 
   describe '#database_column_type' do
     it 'returns :boolean' do
-      expect(filter.database_column_type).to eql :boolean
+      expect(filter.database_column_type).to be :boolean
     end
   end
 end