active_interaction 0.5.0 → 0.6.1

data/spec/active_interaction/integration/array_interaction_spec.rb

@@ -37,7 +37,7 @@ describe ArrayInteraction do
         Class.new(ActiveInteraction::Base) do
           array :a, default: Object.new
         end
-      }.to raise_error ActiveInteraction::InvalidDefaultValue
+      }.to raise_error ActiveInteraction::InvalidDefaultError
     end
   end
 
@@ -49,27 +49,7 @@ describe ArrayInteraction do
             array
           end
         end
-      }.to raise_error ActiveInteraction::InvalidDefaultValue
-    end
-  end
-
-  context 'with a validly nested default' do
-    let(:described_class) do
-      Class.new(ActiveInteraction::Base) do
-        array :a do
-          array default: [rand]
-        end
-        def execute; a end
-      end
-    end
-    let(:options) { { a: [] } }
-
-    it 'does not raise an error' do
-      expect { described_class.run(options) }.to_not raise_error
-    end
-
-    it 'ignores the nested default value' do
-      expect(described_class.run!(options)).to eq options[:a]
+      }.to raise_error ActiveInteraction::InvalidDefaultError
     end
   end
 end

data/spec/active_interaction/integration/hash_interaction_spec.rb

@@ -4,8 +4,8 @@ class HashInteraction < ActiveInteraction::Base
   hash :a do
     hash :x
   end
-  hash :b, default: { x: {} } do
-    hash :x
+  hash :b, default: {} do
+    hash :x, default: {}
   end
 
   def execute
@@ -23,7 +23,7 @@ describe HashInteraction do
     before { options.merge!(a: a) }
 
     it 'returns the correct value for :a' do
-      expect(result[:a]).to eq a
+      expect(result[:a]).to eq a.symbolize_keys
     end
 
     it 'returns the correct value for :b' do
@@ -37,7 +37,7 @@ describe HashInteraction do
         Class.new(ActiveInteraction::Base) do
           hash :a, default: Object.new
         end
-      }.to raise_error ActiveInteraction::InvalidDefaultValue
+      }.to raise_error ActiveInteraction::InvalidDefaultError
     end
   end
 
@@ -49,27 +49,7 @@ describe HashInteraction do
             hash :x
           end
         end
-      }.to raise_error ActiveInteraction::InvalidDefaultValue
-    end
-  end
-
-  context 'with a validly nested default' do
-    let(:described_class) do
-      Class.new(ActiveInteraction::Base) do
-        hash :a do
-          hash :x, default: { y: rand }
-        end
-        def execute; a end
-      end
-    end
-    let(:options) { { a: { x: {} } } }
-
-    it 'does not raise an error' do
-      expect { described_class.run(options) }.to_not raise_error
-    end
-
-    it 'merges the nested default value' do
-      expect(described_class.run!(options)[:x]).to have_key(:y)
+      }.to raise_error ActiveInteraction::InvalidDefaultError
     end
   end
 end

data/spec/active_interaction/integration/symbol_interaction_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'SymbolInteraction' do
+  it_behaves_like 'an interaction', :symbol, -> { SecureRandom.hex.to_sym }
+end

data/spec/active_interaction/method_missing_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe ActiveInteraction::MethodMissing do
+  let(:model) do
+    Class.new do
+      include ActiveInteraction::MethodMissing
+    end
+  end
+
+  subject(:instance) { model.new }
+
+  describe '#method_missing' do
+    context 'with invalid slug' do
+      let(:slug) { :slug }
+
+      it 'calls super' do
+        expect {
+          instance.method_missing(slug)
+        }.to raise_error NoMethodError
+      end
+    end
+
+    context 'with valid slug' do
+      let(:filter) { ActiveInteraction::Filter.factory(slug) }
+      let(:slug) { :boolean }
+
+      it 'returns self' do
+        expect(instance.method_missing(slug)).to eq instance
+      end
+
+      it 'yields' do
+        expect { |b|
+          instance.method_missing(slug, &b)
+        }.to yield_with_args(filter, [], {})
+      end
+
+      context 'with names' do
+        let(:names) { [:a, :b, :c] }
+
+        it 'yields' do
+          expect { |b|
+            instance.method_missing(:boolean, *names, &b)
+          }.to yield_with_args(filter, names, {})
+        end
+      end
+
+      context 'with options' do
+        let(:options) { { a: nil, b: false, c: true } }
+
+        it 'yields' do
+          expect { |b|
+            instance.method_missing(:boolean, options, &b)
+          }.to yield_with_args(filter, [], options)
+        end
+      end
+
+      context 'with names & options' do
+        let(:names) { [:a, :b, :c] }
+        let(:options) { { a: nil, b: false, c: true } }
+
+        it 'yields' do
+          expect { |b|
+            instance.method_missing(:boolean, *names, options, &b)
+          }.to yield_with_args(filter, names, options)
+        end
+      end
+    end
+  end
+end

data/spec/active_interaction/validation_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe ActiveInteraction::Validation do
+  describe '.validate(filters, inputs)' do
+    let(:inputs) { {} }
+    let(:filter) { ActiveInteraction::Filter.new(:name, {}) }
+    let(:filters) { ActiveInteraction::Filters.new.add(filter) }
+    let(:result) { described_class.validate(filters, inputs) }
+
+    context 'no filters are given' do
+      let(:filters) { ActiveInteraction::Filters.new }
+
+      it 'returns no errors' do
+        expect(result).to eq []
+      end
+    end
+
+    context 'filter.cast returns a value' do
+      let(:inputs) { {name: 1} }
+
+      before do
+        filter.stub(:cast).and_return(1)
+      end
+
+      it 'returns no errors' do
+        expect(result).to eq []
+      end
+    end
+
+    context 'filter throws' do
+      before do
+        filter.stub(:cast).and_raise(exception)
+      end
+
+      context 'InvalidValueError' do
+        let(:exception) { ActiveInteraction::InvalidValueError }
+        let(:filter) { ActiveInteraction::FloatFilter.new(:name, {}) }
+
+        it 'returns an :invalid_nested error' do
+          type = I18n.translate("#{ActiveInteraction::Base.i18n_scope}.types.#{filter.class.slug.to_s}")
+
+          expect(result).to eq [[filter.name, :invalid, nil, type: type]]
+        end
+      end
+
+      context 'MissingValueError' do
+        let(:exception) { ActiveInteraction::MissingValueError }
+
+        it 'returns an :invalid_nested error' do
+          expect(result).to eq [[filter.name, :missing]]
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,3 +4,9 @@ Coveralls.wear!
 require 'active_interaction'
 
 Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run_including :focus
+end

data/spec/support/filters.rb

@@ -1,37 +1,191 @@
 shared_context 'filters' do
-  let(:key) { SecureRandom.hex }
-  let(:value) { nil }
+  let(:block) { nil }
+  let(:name) { SecureRandom.hex.to_sym }
   let(:options) { {} }
-  let(:block) { Proc.new {} }
-  subject(:result) { described_class.prepare(key, value, options, &block) }
+
+  subject(:filter) { described_class.new(name, options, &block) }
+
+  shared_context 'optional' do
+    before do
+      options.merge!(default: nil)
+    end
+  end
+
+  shared_context 'required' do
+    before do
+      options.delete(:default)
+    end
+  end
 end
 
 shared_examples_for 'a filter' do
   include_context 'filters'
 
-  context '.prepare(key, value, options = {}, &block)' do
-    context 'with nil' do
+  describe '.factory' do
+    context 'with an invalid slug' do
       it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::MissingValue
+        expect {
+          described_class.factory(:invalid)
+        }.to raise_error ActiveInteraction::MissingFilterError
+      end
+    end
+
+    context 'with a valid slug' do
+      it 'returns a Filter' do
+        expect(
+          described_class.factory(described_class.slug)
+        ).to eq described_class
+      end
+    end
+  end
+
+  describe '.slug' do
+    it 'returns a symbol' do
+      expect(described_class.slug).to be_a Symbol
+    end
+  end
+
+  describe '#cast' do
+    let(:value) { nil }
+
+    context 'optional' do
+      include_context 'optional'
+
+      it 'returns nil' do
+        expect(filter.cast(value)).to be_nil
       end
     end
 
-    context 'with anything else' do
-      let(:value) { Object.new }
+    context 'required' do
+      include_context 'required'
 
       it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::InvalidValue
+        expect {
+          filter.cast(value)
+        }.to raise_error ActiveInteraction::MissingValueError
+      end
+
+      context 'with an invalid default' do
+        let(:value) { Object.new }
+
+        it 'raises an error' do
+          expect {
+            filter.cast(value)
+          }.to raise_error ActiveInteraction::InvalidValueError
+        end
       end
     end
+  end
+
+  describe '#clean' do
+    let(:value) { nil }
 
     context 'optional' do
-      before { options.merge!(allow_nil: true) }
+      include_context 'optional'
+
+      it 'returns the default' do
+        expect(filter.clean(value)).to eq options[:default]
+      end
+    end
 
-      context 'with nil' do
-        it 'returns nil' do
-          expect(result).to be_nil
+    context 'required' do
+      include_context 'required'
+
+      it 'raises an error' do
+        expect {
+          filter.clean(value)
+        }.to raise_error ActiveInteraction::MissingValueError
+      end
+
+      context 'with an invalid value' do
+        let(:value) { Object.new }
+
+        it 'raises an error' do
+          expect {
+            filter.clean(value)
+          }.to raise_error ActiveInteraction::InvalidValueError
         end
       end
     end
+
+    context 'with an invalid default' do
+      before do
+        options.merge!(default: Object.new)
+      end
+
+      it 'raises an error' do
+        expect {
+          filter.clean(value)
+        }.to raise_error ActiveInteraction::InvalidDefaultError
+      end
+    end
+  end
+
+  describe '#default' do
+    context 'optional' do
+      include_context 'optional'
+
+      it 'returns the default' do
+        expect(filter.default).to eq options[:default]
+      end
+    end
+
+    context 'required' do
+      include_context 'required'
+
+      it 'raises an error' do
+        expect {
+          filter.default
+        }.to raise_error ActiveInteraction::NoDefaultError
+      end
+    end
+
+    context 'with an invalid default' do
+      before do
+        options.merge!(default: Object.new)
+      end
+
+      it 'raises an error' do
+        expect {
+          filter.default
+        }.to raise_error ActiveInteraction::InvalidDefaultError
+      end
+    end
+  end
+
+  describe '#filters' do
+    it 'returns Filters' do
+      expect(filter.filters).to be_an ActiveInteraction::Filters
+    end
+  end
+
+  describe '#has_default?' do
+    context 'optional' do
+      include_context 'optional'
+
+      it 'returns true' do
+        expect(filter).to have_default
+      end
+    end
+
+    context 'required' do
+      include_context 'required'
+
+      it 'returns false' do
+        expect(filter).to_not have_default
+      end
+    end
+  end
+
+  describe '#name' do
+    it 'returns the name' do
+      expect(filter.name).to eq name
+    end
+  end
+
+  describe '#options' do
+    it 'returns the options' do
+      expect(filter.options).to eq options
+    end
   end
 end

data/spec/support/interactions.rb

@@ -1,3 +1,12 @@
+class TestInteraction < ActiveInteraction::Base
+  def self.name
+    SecureRandom.hex
+  end
+
+  def execute
+  end
+end
+
 shared_context 'interactions' do
   let(:options) { {} }
   let(:outcome) { described_class.run(options) }
@@ -8,25 +17,18 @@ shared_examples_for 'an interaction' do |type, generator, filter_options = {}|
   include_context 'interactions'
 
   let(:described_class) do
-    Class.new(ActiveInteraction::Base) do
+    Class.new(TestInteraction) do
       send(type, :required, filter_options)
-      send(type, :optional, filter_options.merge(allow_nil: true))
+      send(type, :optional, filter_options.merge(default: nil))
       send(type, :default, filter_options.merge(default: generator.call))
-      send(type, :nil_default,
-           filter_options.merge(allow_nil: true, default: nil))
       send(type, :defaults_1, :defaults_2,
            filter_options.merge(default: generator.call))
 
-      def self.name
-        SecureRandom.hex
-      end
-
       def execute
         {
           required: required,
           optional: optional,
           default: default,
-          nil_default: nil_default,
           defaults_1: defaults_1,
           defaults_2: defaults_2
         }
@@ -66,10 +68,6 @@ shared_examples_for 'an interaction' do |type, generator, filter_options = {}|
       expect(result[:default]).to_not be_nil
     end
 
-    it 'returns nil for :nil_default' do
-      expect(result[:nil_default]).to be_nil
-    end
-
     it 'does not return nil for :defaults_1' do
       expect(result[:defaults_1]).to_not be_nil
     end