active_interaction 0.5.0 → 0.6.1

data/spec/active_interaction/filters/hash_filter_spec.rb

@@ -1,58 +1,67 @@
 require 'spec_helper'
 
-describe ActiveInteraction::HashFilter do
+describe ActiveInteraction::HashFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  context 'with a nested nameless filter' do
+    let(:block) { Proc.new { hash } }
+
+    it 'raises an error' do
+      expect { filter }.to raise_error ActiveInteraction::InvalidFilterError
+    end
+  end
+
+  describe '#cast' do
     context 'with a Hash' do
       let(:value) { {} }
 
       it 'returns the Hash' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with a block' do
+    context 'with a non-empty Hash' do
+      let(:value) { { a: {} } }
+
+      it 'returns an empty Hash' do
+        expect(filter.cast(value)).to eq({})
+      end
+    end
+
+    context 'with a nested filter' do
       let(:block) { Proc.new { hash :a } }
 
-      context 'with a Hash containing a Hash' do
+      context 'with a Hash' do
         let(:value) { { a: {} } }
 
         it 'returns the Hash' do
-          expect(result).to eql value
-        end
-      end
-
-      context 'with a Hash containing anything else' do
-        let(:value) { { a: Object.new } }
-
-        it 'raises an error' do
-          expect {
-            result
-          }.to raise_error ActiveInteraction::InvalidNestedValue
+          expect(filter.cast(value)).to eq value
         end
       end
     end
+  end
 
-    context 'with a block with multiple filters' do
-      let(:block) { Proc.new { hash :a; hash :b } }
-
-      context 'with a Hash containing Hashes' do
-        let(:value) { { a: {}, b: {} } }
+  describe '#default' do
+    context 'with a Hash' do
+      before do
+        options.merge!(default: {})
+      end
 
-        it 'returns the Hash' do
-          expect(result).to eql value
-        end
+      it 'returns the Hash' do
+        expect(filter.default).to eq options[:default]
       end
     end
 
-    context 'with a nested block' do
-      let(:block) { Proc.new { hash :a do; hash :b end } }
-      let(:value) { { a: { b: {} } } }
+    context 'with a non-empty Hash' do
+      before do
+        options.merge!(default: { a: {} })
+      end
 
-      it 'returns the Hash' do
-        expect(result).to eql value
+      it 'raises an error' do
+        expect {
+          filter.default
+        }.to raise_error ActiveInteraction::InvalidDefaultError
       end
     end
   end

data/spec/active_interaction/filters/integer_filter_spec.rb

@@ -1,31 +1,41 @@
 require 'spec_helper'
 
-describe ActiveInteraction::IntegerFilter do
+describe ActiveInteraction::IntegerFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  describe '#cast' do
     context 'with an Integer' do
       let(:value) { rand(1 << 16) }
 
       it 'returns the Integer' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with a valid String' do
+    context 'with a Numeric' do
+      let(:value) { rand(1 << 16) + rand }
+
+      it 'returns an Integer' do
+        expect(filter.cast(value)).to eq value.to_i
+      end
+    end
+
+    context 'with a String' do
       let(:value) { rand(1 << 16).to_s }
 
-      it 'converts the String' do
-        expect(result).to eql Integer(value)
+      it 'returns an Integer' do
+        expect(filter.cast(value)).to eq Integer(value)
       end
     end
 
     context 'with an invalid String' do
-      let(:value) { 'not a valid Integer' }
+      let(:value) { 'invalid' }
 
       it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::InvalidValue
+        expect {
+          filter.cast(value)
+        }.to raise_error ActiveInteraction::InvalidValueError
       end
     end
   end

data/spec/active_interaction/filters/model_filter_spec.rb

@@ -1,39 +1,43 @@
 require 'spec_helper'
 
-TestModel = Class.new
+class Model; end
 
-describe ActiveInteraction::ModelFilter do
+describe ActiveInteraction::ModelFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  before { options.merge!(class: TestModel) }
+  before do
+    options.merge!(class: Model)
+  end
 
-  describe '.prepare(key, value, options = {}, &block)' do
-    shared_examples 'type checking' do
-      context 'with the right class' do
-        let(:value) { TestModel.new }
+  describe '#cast' do
+    let(:value) { Model.new }
 
-        it 'returns the instance' do
-          expect(result).to eql value
-        end
+    context 'with class as a Class' do
+      it 'returns the instance' do
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with options[:class] as a Class' do
-      include_examples 'type checking'
-    end
-
-    context 'with options[:class] as a valid String' do
-      include_examples 'type checking'
+    context 'with class as a String' do
+      before do
+        options.merge!(class: Model.name)
+      end
 
-      before { options.merge!(class: options[:class].to_s) }
+      it 'returns the instance' do
+        expect(filter.cast(value)).to eq value
+      end
     end
 
-    context 'with options[:class] as an invalid String' do
-      before { options.merge!(class: 'not a valid Class') }
+    context 'with class as an invalid String' do
+      before do
+        options.merge!(class: 'invalid')
+      end
 
       it 'raises an error' do
-        expect { result }.to raise_error NameError
+        expect {
+          filter.cast(value)
+        }.to raise_error ActiveInteraction::InvalidClassError
       end
     end
   end

data/spec/active_interaction/filters/string_filter_spec.rb

@@ -1,30 +1,36 @@
 require 'spec_helper'
 
-describe ActiveInteraction::StringFilter do
+describe ActiveInteraction::StringFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  shared_context 'without strip' do
+    before do
+      options.merge!(strip: false)
+    end
+  end
+
+  describe '#cast' do
     context 'with a String' do
       let(:value) { SecureRandom.hex }
 
       it 'returns the String' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
       end
     end
 
     context 'with a strippable String' do
       let(:value) { " #{SecureRandom.hex} " }
 
-      it 'returns the stripped String' do
-        expect(result).to eql value.strip
+      it 'returns the stripped string' do
+        expect(filter.cast(value)).to eq value.strip
       end
 
-      context 'with options[:strip] as false' do
-        before { options.merge!(strip: false) }
+      context 'without strip' do
+        include_context 'without strip'
 
         it 'returns the String' do
-          expect(result).to eql value
+          expect(filter.cast(value)).to eq value
         end
       end
     end

data/spec/active_interaction/filters/symbol_filter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ActiveInteraction::SymbolFilter, :filter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '#cast' do
+    context 'with a Symbol' do
+      let(:value) { SecureRandom.hex.to_sym }
+
+      it 'returns the Symbol' do
+        expect(filter.cast(value)).to eq value
+      end
+    end
+
+    context 'with a String' do
+      let(:value) { SecureRandom.hex }
+
+      it 'returns a Symbol' do
+        expect(filter.cast(value)).to eq value.to_sym
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/time_filter_spec.rb

@@ -1,96 +1,60 @@
 require 'spec_helper'
 
-describe ActiveInteraction::TimeFilter do
+describe ActiveInteraction::TimeFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
-    context 'with a Time' do
-      let(:value) { Time.now }
+  shared_context 'with format' do
+    let(:format) { '%d/%m/%Y %H:%M:%S %z' }
 
-      it 'returns the Time' do
-        expect(result).to eql value
-      end
+    before do
+      options.merge!(format: format)
     end
+  end
 
-    shared_examples 'conversion' do
-      context 'with a Float' do
-        let(:value) { rand }
-
-        it 'converts the Float' do
-          expect(result).to eql Time.at(value)
-        end
-      end
-
-      context 'with an Integer' do
-        let(:value) { rand(1 << 16) }
+  describe '#cast' do
+    context 'with a Time' do
+      let(:value) { Time.new }
 
-        it 'converts the Integer' do
-          expect(result).to eql Time.at(value)
-        end
+      it 'returns the Time' do
+        expect(filter.cast(value)).to eq value
       end
+    end
 
-      context 'with a valid String' do
-        let(:value) { '2001-01-01T01:01:01+01:01' }
-
-        it 'parses the String' do
-          expect(result).to eql Time.parse(value)
-        end
-
-        context 'with options[:format]' do
-          let(:value) { '01010101012001' }
-
-          before { options.merge!(format: '%S%M%H%d%m%Y') }
+    context 'with a String' do
+      let(:value) { '2011-12-13 14:15:16 +1718' }
 
-          it 'parses the String' do
-            expect(result).to eql Time.strptime(value, options[:format])
-          end
-        end
+      it 'returns a Time' do
+        expect(filter.cast(value)).to eq Time.parse(value)
       end
 
-      context 'with an invalid String' do
-        let(:value) { 'not a valid Time' }
+      context 'with format' do
+        include_context 'with format'
 
-        it 'raises an error' do
-          expect { result }.to raise_error ActiveInteraction::InvalidValue
-        end
-
-        context 'with options[:format]' do
-          before { options.merge!(format: '%S%M%H%d%m%Y') }
+        let(:value) { '13/12/2011 14:15:16 +1718' }
 
-          it 'raises an error' do
-            expect { result }.to raise_error ActiveInteraction::InvalidValue
-          end
+        it 'returns a Time' do
+          expect(filter.cast(value)).to eq Time.strptime(value, format)
         end
       end
     end
 
-    context 'without Time.zone' do
-      include_examples 'conversion'
-    end
+    context 'with an invalid String' do
+      let(:value) { 'invalid' }
 
-    context 'with Time.zone' do
-      context 'as nil' do
-        include_examples 'conversion'
-
-        before do
-          allow(Time).to receive(:zone).and_return(nil)
-        end
-
-        after do
-          expect(Time).to have_received(:zone).once.with(no_args)
-        end
+      it 'raises an error' do
+        expect {
+          filter.cast(value)
+        }.to raise_error ActiveInteraction::InvalidValueError
       end
 
-      context 'as Time' do
-        include_examples 'conversion'
-
-        before do
-          allow(Time).to receive(:zone).and_return(Time)
-        end
+      context 'with format' do
+        include_context 'with format'
 
-        after do
-          expect(Time).to have_received(:zone).twice.with(no_args)
+        it do
+          expect {
+            filter.cast(value)
+          }.to raise_error ActiveInteraction::InvalidValueError
         end
       end
     end

data/spec/active_interaction/filters_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ActiveInteraction::Filters do
+  describe '#each' do
+    it 'returns an Enumerator' do
+      expect(subject.each).to be_an Enumerator
+    end
+  end
+
+  describe '#add(filter)' do
+    it 'returns self' do
+      expect(subject.add(double)).to equal subject
+    end
+
+    it 'adds the filter' do
+      filter = double
+
+      expect(subject.add(filter).to_a).to eql [filter]
+    end
+  end
+end

data/spec/active_interaction/i18n_spec.rb

@@ -52,21 +52,6 @@ describe I18nInteraction do
         end
       end
 
-      context ':invalid_nested' do
-        let(:key) {
-          "#{described_class.i18n_scope}.errors.messages.invalid_nested"
-        }
-
-        it 'has a translation' do
-          expect { translation }.to_not raise_error
-        end
-
-        it 'returns the translation' do
-          options.merge!(a: { x: Object.new })
-          expect(outcome.errors[:a]).to eq [translation]
-        end
-      end
-
       context ':missing' do
         let(:key) { "#{described_class.i18n_scope}.errors.messages.missing" }