active_interaction 4.0.6 → 5.1.0

data/spec/active_interaction/base_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'action_controller'
+require 'active_support/core_ext/kernel/reporting'
 
 InteractionWithFilter = Class.new(TestInteraction) do
   float :thing
@@ -34,10 +35,10 @@ InterruptInteraction = Class.new(TestInteraction) do
 end
 
 describe ActiveInteraction::Base do
-  include_context 'interactions'
-
   subject(:interaction) { described_class.new(inputs) }
 
+  include_context 'interactions'
+
   describe '.new(inputs = {})' do
     it 'does not set instance vars for reserved input names' do
       key = :execute
@@ -83,7 +84,7 @@ describe ActiveInteraction::Base do
         before { inputs[:thing] = 1 }
 
         it 'sets the attribute to the filtered value' do
-          expect(interaction.thing).to eql 1.0
+          expect(interaction.thing).to be 1.0
         end
       end
 
@@ -181,8 +182,8 @@ describe ActiveInteraction::Base do
 
     it 'warns when redefining a filter' do
       klass = Class.new(described_class)
-      expect(klass).to receive(:warn).with(/\AWARNING:/)
-      klass.boolean :thing
+      allow(klass).to receive(:warn)
+      expect(klass.boolean(:thing)).to have_received(:warn).with(/\AWARNING:/)
     end
 
     describe '.run(inputs = {})' do
@@ -204,18 +205,18 @@ describe ActiveInteraction::Base do
         before { inputs[:thing] = thing }
 
         context 'failing runtime validations' do
-          before do
-            @execute = described_class.instance_method(:execute)
+          around do |example|
+            old_method = described_class.instance_method(:execute)
             described_class.send(:define_method, :execute) do
               errors.add(:thing, 'is invalid')
               errors.add(:thing, :invalid)
               true
             end
-          end
 
-          after do
+            example.run
+
             silence_warnings do
-              described_class.send(:define_method, :execute, @execute)
+              described_class.send(:define_method, :execute, old_method)
             end
           end
 
@@ -279,7 +280,7 @@ describe ActiveInteraction::Base do
     let(:inputs) { { thing: 1, other: other_val } }
 
     it 'casts filtered inputs' do
-      expect(interaction.inputs[:thing]).to eql 1.0
+      expect(interaction.inputs[:thing]).to be 1.0
     end
 
     it 'strips non-filtered inputs' do
@@ -293,17 +294,28 @@ describe ActiveInteraction::Base do
     let(:z) { rand }
 
     context 'with valid composition' do
-      before do
-        inputs[:x] = x
-        inputs[:z] = z
-      end
+      context 'when inputs is a hash' do
+        let(:inputs) { { x: x, z: z } }
 
-      it 'is valid' do
-        expect(outcome).to be_valid
+        it 'is valid' do
+          expect(outcome).to be_valid
+        end
+
+        it 'returns the sum' do
+          expect(result).to eql x + z
+        end
       end
 
-      it 'returns the sum' do
-        expect(result).to eql x + z
+      context 'when inputs is an ActiveInteraction::Inputs' do
+        let(:inputs) { ActiveInteraction::Inputs.new({ x: x, z: z }, described_class.new) }
+
+        it 'is valid' do
+          expect(outcome).to be_valid
+        end
+
+        it 'returns the sum' do
+          expect(result).to eql x + z
+        end
       end
     end
 
@@ -332,232 +344,6 @@ describe ActiveInteraction::Base do
     end
   end
 
-  describe '#given?' do
-    let(:described_class) do
-      Class.new(TestInteraction) do
-        float :x,
-          default: nil
-
-        def execute
-          given?(:x)
-        end
-      end
-    end
-
-    it 'is false when the input is not given' do
-      expect(result).to be false
-    end
-
-    it 'is true when the input is nil' do
-      inputs[:x] = nil
-      expect(result).to be true
-    end
-
-    it 'is true when the input is given' do
-      inputs[:x] = rand
-      expect(result).to be true
-    end
-
-    it 'symbolizes its argument' do
-      described_class.class_exec do
-        def execute
-          given?('x')
-        end
-      end
-
-      inputs[:x] = rand
-      expect(result).to be true
-    end
-
-    it 'only tracks inputs with filters' do
-      described_class.class_exec do
-        def execute
-          given?(:y)
-        end
-      end
-
-      inputs[:y] = rand
-      expect(result).to be false
-    end
-
-    context 'nested hash values' do
-      let(:described_class) do
-        Class.new(TestInteraction) 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
-
-        inputs[:x] = { y: false }
-        expect(result).to be true
-      end
-
-      it 'is true when the nested inputs strings are given' do
-        described_class.class_exec do
-          def execute
-            given?(:x, :y)
-          end
-        end
-
-        inputs['x'] = { 'y' => false }
-        expect(result).to be true
-      end
-
-      it 'is false when the nested input is not given' do
-        described_class.class_exec do
-          def execute
-            given?(:x, :y)
-          end
-        end
-
-        inputs[:x] = {}
-        expect(result).to be false
-      end
-
-      it 'is false when the first input is not given' do
-        described_class.class_exec do
-          def execute
-            given?(:x, :y)
-          end
-        end
-
-        expect(result).to be false
-      end
-
-      it 'is false when the first input is nil' do
-        described_class.class_exec do
-          def execute
-            given?(:x, :y)
-          end
-        end
-
-        inputs[:x] = nil
-        expect(result).to be false
-      end
-
-      it 'returns false if you go too far' do
-        described_class.class_exec do
-          def execute
-            given?(:x, :y, :z)
-          end
-        end
-
-        inputs[:x] = { y: true }
-        expect(result).to be false
-      end
-    end
-
-    context 'nested array values' do
-      let(:described_class) do
-        Class.new(TestInteraction) 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
-          described_class.class_exec do
-            def execute
-              given?(:x, 0, :y)
-            end
-          end
-
-          inputs[:x] = [{ y: true }]
-          expect(result).to be true
-        end
-
-        it 'returns false if not found' do
-          described_class.class_exec do
-            def execute
-              given?(:x, 0, :y)
-            end
-          end
-
-          inputs[:x] = []
-          expect(result).to be false
-        end
-      end
-
-      context 'has a negative index' do
-        it 'returns true if found' do
-          described_class.class_exec do
-            def execute
-              given?(:x, -1, :y)
-            end
-          end
-
-          inputs[:x] = [{ y: true }]
-          expect(result).to be true
-        end
-
-        it 'returns false if not found' do
-          described_class.class_exec do
-            def execute
-              given?(:x, -1, :y)
-            end
-          end
-
-          inputs[:x] = []
-          expect(result).to be false
-        end
-      end
-
-      it 'returns false if you go too far' do
-        described_class.class_exec do
-          def execute
-            given?(:x, 10, :y)
-          end
-        end
-
-        inputs[:x] = [{}]
-        expect(result).to be false
-      end
-    end
-
-    context 'multi-part date values' do
-      let(:described_class) do
-        Class.new(TestInteraction) do
-          date :thing,
-            default: nil
-
-          def execute
-            given?(:thing)
-          end
-        end
-      end
-
-      it 'returns true when the input is given' do
-        inputs.merge!(
-          'thing(1i)' => '2020',
-          'thing(2i)' => '12',
-          'thing(3i)' => '31'
-        )
-        expect(result).to be true
-      end
-
-      it 'returns false if not found' do
-        expect(result).to be false
-      end
-    end
-  end
-
   context 'inheritance' do
     context 'filters' do
       let(:described_class) { InteractionWithFilter }
@@ -680,7 +466,7 @@ describe ActiveInteraction::Base do
   context 'callbacks' do
     let(:described_class) { Class.new(TestInteraction) }
 
-    %w[type_check validate execute].each do |name|
+    %w[filter validate execute].each do |name|
       %w[before after around].map(&:to_sym).each do |type|
         it "runs the #{type} #{name} callback" do
           called = false
@@ -691,9 +477,9 @@ describe ActiveInteraction::Base do
       end
     end
 
-    context 'with errors during type_check' do
+    context 'with errors during filter' do
       before do
-        described_class.set_callback(:type_check, :before) do
+        described_class.set_callback(:filter, :before) do
           errors.add(:base)
         end
       end

data/spec/active_interaction/concerns/active_modelable_spec.rb

@@ -15,19 +15,19 @@ shared_examples_for 'ActiveModel' do
 end
 
 describe ActiveInteraction::ActiveModelable do
-  include_context 'concerns', ActiveInteraction::ActiveModelable
+  include_context 'concerns', described_class
 
   it_behaves_like 'ActiveModel'
 
   describe '.i18n_scope' do
     it 'returns the scope' do
-      expect(klass.i18n_scope).to eql :active_interaction
+      expect(klass.i18n_scope).to be :active_interaction
     end
   end
 
   describe '#i18n_scope' do
     it 'returns the scope' do
-      expect(instance.i18n_scope).to eql :active_interaction
+      expect(instance.i18n_scope).to be :active_interaction
     end
   end
 

data/spec/active_interaction/concerns/active_recordable_spec.rb

@@ -23,27 +23,27 @@ describe ActiveInteraction::ActiveRecordable do
     context 'name is an input name' do
       let(:name) { described_class.filters.keys.first }
 
-      it 'returns a FilterColumn' do
-        expect(column).to be_a ActiveInteraction::FilterColumn
+      it 'returns a Filter::Column' do
+        expect(column).to be_a ActiveInteraction::Filter::Column
       end
 
-      it 'returns a FilterColumn of type boolean' do
-        expect(column.type).to eql :float
+      it 'returns a Filter::Column of type boolean' do
+        expect(column.type).to be :float
       end
     end
   end
 
   describe '#has_attribute?' do
     it 'returns true if the filter exists' do
-      expect(outcome.has_attribute?(:thing)).to be_truthy
+      expect(outcome).to have_attribute(:thing)
     end
 
     it 'works with strings' do
-      expect(outcome.has_attribute?('thing')).to be_truthy
+      expect(outcome).to have_attribute('thing')
     end
 
     it 'returns false if the filter does not exist' do
-      expect(outcome.has_attribute?(:not_a_filter)).to be_falsey
+      expect(outcome).to_not have_attribute(:not_a_filter)
     end
   end
 end

data/spec/active_interaction/concerns/hashable_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe ActiveInteraction::Hashable do
-  include_context 'concerns', ActiveInteraction::Hashable
+  include_context 'concerns', described_class
 
   describe '#hash(*args, &block)' do
     context 'with no arguments' do
-      let(:hash) { subject.hash }
+      let(:hash) { instance.hash }
 
       it 'returns an Integer' do
         expect(hash).to be_an Integer
@@ -14,28 +14,28 @@ describe ActiveInteraction::Hashable do
 
     context 'with arguments' do
       let(:arguments) { [:attribute, {}] }
-      let(:hash) { subject.hash(*arguments) }
+      let(:hash) { instance.hash(*arguments) }
 
-      before { allow(subject).to receive(:method_missing) }
+      before { allow(instance).to receive(:method_missing) }
 
       it 'calls method_missing' do
         hash
-        expect(subject).to have_received(:method_missing).once
+        expect(instance).to have_received(:method_missing).once
           .with(:hash, *arguments)
       end
 
       context 'with a block' do
         let(:block) { proc {} }
-        let(:hash) { subject.hash(*arguments, &block) }
+        let(:hash) { instance.hash(*arguments, &block) }
 
         it 'calls method_missing' do
           hash
-          expect(subject).to have_received(:method_missing).once
+          expect(instance).to have_received(:method_missing).once
             .with(:hash, *arguments)
         end
 
         it 'passes the block to method_missing' do
-          allow(subject).to receive(:method_missing) do |*, &other_block|
+          allow(instance).to receive(:method_missing) do |*, &other_block|
             expect(other_block).to equal block
           end
           hash(&block)

data/spec/active_interaction/concerns/missable_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe ActiveInteraction::Missable do
-  include_context 'concerns', ActiveInteraction::Missable
+  include_context 'concerns', described_class
 
   describe '#respond_to?(slug, include_all = false)' do
     context 'with invalid slug' do
       let(:slug) { :slug }
 
       it 'returns false' do
-        expect(instance.respond_to?(slug)).to be_falsey
+        expect(instance).to_not respond_to(slug)
       end
     end
 
@@ -16,7 +16,7 @@ describe ActiveInteraction::Missable do
       let(:slug) { :boolean }
 
       it 'returns true' do
-        expect(instance.respond_to?(slug)).to be_truthy
+        expect(instance).to respond_to(slug)
       end
     end
   end
@@ -45,7 +45,7 @@ describe ActiveInteraction::Missable do
 
       it 'calls super' do
         expect do
-          instance.method_missing(slug)
+          instance.public_send(slug)
         end.to raise_error NameError
       end
     end
@@ -55,12 +55,12 @@ describe ActiveInteraction::Missable do
       let(:slug) { :boolean }
 
       it 'returns self' do
-        expect(instance.method_missing(slug)).to eql instance
+        expect(instance.public_send(slug)).to eql instance
       end
 
       it 'yields' do
         expect do |b|
-          instance.method_missing(slug, &b)
+          instance.public_send(slug, &b)
         end.to yield_with_args(filter, [], {})
       end
 
@@ -69,7 +69,7 @@ describe ActiveInteraction::Missable do
 
         it 'yields' do
           expect do |b|
-            instance.method_missing(:boolean, *names, &b)
+            instance.public_send(:boolean, *names, &b)
           end.to yield_with_args(filter, names, {})
         end
       end
@@ -79,7 +79,7 @@ describe ActiveInteraction::Missable do
 
         it 'yields' do
           expect do |b|
-            instance.method_missing(:boolean, options, &b)
+            instance.public_send(:boolean, options, &b)
           end.to yield_with_args(filter, [], options)
         end
       end
@@ -90,7 +90,7 @@ describe ActiveInteraction::Missable do
 
         it 'yields' do
           expect do |b|
-            instance.method_missing(:boolean, *names, options, &b)
+            instance.public_send(:boolean, *names, options, &b)
           end.to yield_with_args(filter, names, options)
         end
       end

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