active_interaction 0.5.0 → 0.6.1

data/spec/active_interaction/filter_spec.rb

@@ -1,29 +1,21 @@
 require 'spec_helper'
 
-module ActiveInteraction
-  TestFilter = Class.new(Filter)
-end
-
-describe ActiveInteraction::Filter do
-  it_behaves_like 'a filter'
-
-  describe '.factory(type)' do
-    let(:result) { described_class.factory(type) }
+class ActiveInteraction::TestFilter < ActiveInteraction::Filter; end
 
-    context 'with a valid type' do
-      let(:type) { :test }
+describe ActiveInteraction::Filter, :filter do
+  include_context 'filters'
 
-      it 'returns the Class' do
-        expect(result).to eql ActiveInteraction::TestFilter
-      end
+  describe '.slug' do
+    it 'raises an error' do
+      expect {
+        described_class.slug
+      }.to raise_error ActiveInteraction::InvalidClassError
     end
+  end
 
-    context 'with an invalid type' do
-      let(:type) { :not_a_valid_type }
+  context ActiveInteraction::TestFilter do
+    it_behaves_like 'a filter'
 
-      it 'raises an error' do
-        expect { result }.to raise_error NoMethodError
-      end
-    end
+    let(:described_class) { ActiveInteraction::TestFilter }
   end
 end

data/spec/active_interaction/filters/array_filter_spec.rb

@@ -1,55 +1,77 @@
 require 'spec_helper'
 
-describe ActiveInteraction::ArrayFilter do
+describe ActiveInteraction::ArrayFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  context 'with multiple nested filters' do
+    let(:block) { Proc.new { array; array } }
+
+    it 'raises an error' do
+      expect { filter }.to raise_error ActiveInteraction::InvalidFilterError
+    end
+  end
+
+  context 'with a nested name' do
+    let(:block) { Proc.new { array :a } }
+
+    it 'raises an error' do
+      expect { filter }.to raise_error ActiveInteraction::InvalidFilterError
+    end
+  end
+
+  context 'with a nested default' do
+    let(:block) { Proc.new { array default: nil } }
+
+    it 'raises an error' do
+      expect { filter }.to raise_error ActiveInteraction::InvalidDefaultError
+    end
+  end
+
+  describe '#cast' do
     context 'with an Array' do
       let(:value) { [] }
 
       it 'returns the Array' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
+      end
+    end
+
+    context 'with a heterogenous Array' do
+      let(:value) { [[], false, 0.0, {}, 0, '', :''] }
+
+      it 'returns the Array' do
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with a block' do
+    context 'with a nested filter' do
       let(:block) { Proc.new { array } }
 
-      context 'with an Array of Arrays' do
-        let(:value) { [[]] }
+      context 'with an Array' do
+        let(:value) { [] }
 
         it 'returns the Array' do
-          expect(result).to eql value
+          expect(filter.cast(value)).to eq value
         end
       end
 
-      context 'with an Array of anything else' do
-        let(:value) { [Object.new] }
+      context 'with an Array of Arrays' do
+        let(:value) { [[]] }
 
-        it 'raises an error' do
-          expect {
-            result
-          }.to raise_error ActiveInteraction::InvalidNestedValue
+        it 'returns the Array' do
+          expect(filter.cast(value)).to eq value
         end
       end
-    end
-
-    context 'with a nested block' do
-      let(:block) { Proc.new { array { array } } }
-      let(:value) { [[[]]] }
-
-      it 'returns the Array' do
-        expect(result).to eql value
-      end
-    end
 
-    context 'with an invalid block' do
-      let(:block) { Proc.new { array; array } }
-      let(:value) { [] }
+      context 'with a heterogenous Array' do
+        let(:value) { [[], false, 0.0, {}, 0, '', :''] }
 
-      it 'raises an error' do
-        expect { result }.to raise_error ArgumentError
+        it 'raises an error' do
+          expect{
+            filter.cast(value)
+          }.to raise_error ActiveInteraction::InvalidValueError
+        end
       end
     end
   end

data/spec/active_interaction/filters/boolean_filter_spec.rb

@@ -1,31 +1,23 @@
 require 'spec_helper'
 
-describe ActiveInteraction::BooleanFilter do
+describe ActiveInteraction::BooleanFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
-    context 'with true' do
-      let(:value) { true }
-
-      it 'returns true' do
-        expect(result).to eql true
-      end
-    end
-
+  describe '#cast' do
     context 'with false' do
       let(:value) { false }
 
       it 'returns false' do
-        expect(result).to eql false
+        expect(filter.cast(value)).to be_false
       end
     end
 
-    context 'with "1"' do
-      let(:value) { '1' }
+    context 'with true' do
+      let(:value) { true }
 
       it 'returns true' do
-        expect(result).to eql true
+        expect(filter.cast(value)).to be_true
       end
     end
 
@@ -33,7 +25,15 @@ describe ActiveInteraction::BooleanFilter do
       let(:value) { '0' }
 
       it 'returns false' do
-        expect(result).to eql false
+        expect(filter.cast(value)).to be_false
+      end
+    end
+
+    context 'with "1"' do
+      let(:value) { '1' }
+
+      it 'returns true' do
+        expect(filter.cast(value)).to be_true
       end
     end
   end

data/spec/active_interaction/filters/date_filter_spec.rb

@@ -1,48 +1,60 @@
 require 'spec_helper'
 
-describe ActiveInteraction::DateFilter do
+describe ActiveInteraction::DateFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  shared_context 'with format' do
+    let(:format) { '%d/%m/%Y' }
+
+    before do
+      options.merge!(format: format)
+    end
+  end
+
+  describe '#cast' do
     context 'with a Date' do
-      let(:value) { Date.today }
+      let(:value) { Date.new }
 
       it 'returns the Date' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with a valid String' do
-      let(:value) { '2001-01-01' }
+    context 'with a String' do
+      let(:value) { '2011-12-13' }
 
-      it 'parses the String' do
-        expect(result).to eql Date.parse(value)
+      it 'returns a Date' do
+        expect(filter.cast(value)).to eq Date.parse(value)
       end
 
-      context 'with options[:format]' do
-        let(:value) { '01012001' }
+      context 'with format' do
+        include_context 'with format'
 
-        before { options.merge!(format: '%m%d%Y') }
+        let(:value) { '13/12/2011' }
 
-        it 'parses the String' do
-          expect(result).to eql Date.strptime(value, options[:format])
+        it 'returns a Date' do
+          expect(filter.cast(value)).to eq Date.strptime(value, format)
         end
       end
     end
 
     context 'with an invalid String' do
-      let(:value) { 'not a valid Date' }
+      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
 
-      context 'with options[:format]' do
-        before { options.merge!(format: '%m%d%Y') }
+      context 'with format' do
+        include_context 'with format'
 
         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/date_time_filter_spec.rb

@@ -1,48 +1,60 @@
 require 'spec_helper'
 
-describe ActiveInteraction::DateTimeFilter do
+describe ActiveInteraction::DateTimeFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
-    context 'with a DateTime' do
-      let(:value) { DateTime.now }
+  shared_context 'with format' do
+    let(:format) { '%d/%m/%Y %H:%M:%S %:z' }
+
+    before do
+      options.merge!(format: format)
+    end
+  end
+
+  describe '#cast' do
+    context 'with a Datetime' do
+      let(:value) { DateTime.new }
 
       it 'returns the DateTime' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with a valid String' do
-      let(:value) { '2001-01-01T01:01:01+01:01' }
+    context 'with a String' do
+      let(:value) { '2011-12-13T14:15:16+17:18' }
 
-      it 'parses the String' do
-        expect(result).to eql DateTime.parse(value)
+      it 'returns a DateTime' do
+        expect(filter.cast(value)).to eq DateTime.parse(value)
       end
 
-      context 'with options[:format]' do
-        let(:value) { '01010101012001' }
+      context 'with format' do
+        include_context 'with format'
 
-        before { options.merge!(format: '%S%M%H%m%d%Y') }
+        let(:value) { '13/12/2011 14:15:16 +17:18' }
 
-        it 'parses the String' do
-          expect(result).to eql DateTime.strptime(value, options[:format])
+        it 'returns a DateTime' do
+          expect(filter.cast(value)).to eq DateTime.strptime(value, format)
         end
       end
     end
 
     context 'with an invalid String' do
-      let(:value) { 'not a valid DateTine' }
+      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
 
-      context 'with options[:format]' do
-        before { options.merge!(format: '%S%M%H%m%d%Y') }
+      context 'with format' do
+        include_context 'with format'
 
         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/file_filter_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
-describe ActiveInteraction::FileFilter do
+describe ActiveInteraction::FileFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  describe '#cast' do
     context 'with a File' do
-      let(:value) { File.open(__FILE__) }
+      let(:value) { File.new(__FILE__) }
 
       it 'returns the File' do
-        expect(result).to equal value
+        expect(filter.cast(value)).to eq value
       end
     end
 
@@ -17,15 +17,15 @@ describe ActiveInteraction::FileFilter do
       let(:value) { Tempfile.new(SecureRandom.hex) }
 
       it 'returns the Tempfile' do
-        expect(result).to equal value
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with a object that responds to `tempfile`' do
+    context 'with an object that responds to #tempfile' do
       let(:value) { double(tempfile: Tempfile.new(SecureRandom.hex)) }
 
       it 'returns the Tempfile' do
-        expect(result).to equal value.tempfile
+        expect(filter.cast(value)).to eq value.tempfile
       end
     end
   end

data/spec/active_interaction/filters/float_filter_spec.rb

@@ -1,39 +1,41 @@
 require 'spec_helper'
 
-describe ActiveInteraction::FloatFilter do
+describe ActiveInteraction::FloatFilter, :filter do
   include_context 'filters'
   it_behaves_like 'a filter'
 
-  describe '.prepare(key, value, options = {}, &block)' do
+  describe '#cast' do
     context 'with a Float' do
       let(:value) { rand }
 
       it 'returns the Float' do
-        expect(result).to eql value
+        expect(filter.cast(value)).to eq value
       end
     end
 
-    context 'with an Integer' do
+    context 'with a Numeric' do
       let(:value) { rand(1 << 16) }
 
-      it 'converts the Integer' do
-        expect(result).to eql Float(value)
+      it 'returns a Float' do
+        expect(filter.cast(value)).to eq value.to_f
       end
     end
 
-    context 'with a valid String' do
+    context 'with a String' do
       let(:value) { rand.to_s }
 
-      it 'converts the String' do
-        expect(result).to eql Float(value)
+      it 'returns a Float' do
+        expect(filter.cast(value)).to eq Float(value)
       end
     end
 
     context 'with an invalid String' do
-      let(:value) { 'not a valid Float' }
+      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