input_sanitizer 0.1.10 → 0.4.1

data/spec/sanitizer_spec.rb

@@ -1,11 +1,22 @@
 require 'spec_helper'
 
+class NestedSanitizer < InputSanitizer::Sanitizer
+  integer :foo
+end
+
 class BasicSanitizer < InputSanitizer::Sanitizer
   string :x, :y, :z
+  integer :namespaced, :namespace => :value
+  integer :array, :collection => true
+  integer :namespaced_array, :collection => true, :namespace => :value
   integer :num
   date :birthday
   time :updated_at
   custom :cust1, :cust2, :converter => lambda { |v| v.reverse }
+  nested :stuff, :sanitizer => NestedSanitizer, :collection => true, :namespace => :nested
+  custom :custom3, :provide => :num, :converter => lambda { |v, num|
+    num == 1 ? v.reverse : v
+  }
 end
 
 class BrokenCustomSanitizer < InputSanitizer::Sanitizer
@@ -28,12 +39,17 @@ class RequiredCustom < BasicSanitizer
   custom :c1, :required => true, :converter => lambda { |v| v }
 end
 
+class DefaultParameters < BasicSanitizer
+  integer :funky_number, :default => 5
+  custom :fixed_stuff, :converter => lambda {|v| v }, :default => "default string"
+end
+
 describe InputSanitizer::Sanitizer do
   let(:sanitizer) { BasicSanitizer.new(@params) }
 
   describe ".clean" do
     it "returns cleaned data" do
-      clean_data = mock()
+      clean_data = double
       BasicSanitizer.any_instance.should_receive(:cleaned).and_return(clean_data)
       BasicSanitizer.clean({}).should be(clean_data)
     end
@@ -57,6 +73,12 @@ describe InputSanitizer::Sanitizer do
       cleaned.should_not have_key(:d)
     end
 
+    it "does not include ommited fields" do
+      @params = { "x" => 1, "z" => 3 }
+
+      cleaned.should_not have_key(:y)
+    end
+
     it "freezes cleaned hash" do
       @params = {}
 
@@ -83,6 +105,30 @@ describe InputSanitizer::Sanitizer do
       cleaned.should_not have_key(:d)
     end
 
+    it "preserves namespace" do
+      value = { :value => 5 }
+      @params = { :namespaced => value }
+
+      cleaned[:namespaced].should eq(value)
+    end
+
+    it "maps values for collection fields" do
+      numbers = [3, 5, 6]
+      @params = { :array => numbers }
+
+      cleaned[:array].should eq(numbers)
+    end
+
+    it "maps values for collection fields with namespace" do
+      numbers = [
+        { :value => 2 },
+        { :value => 5 }
+      ]
+      @params = { :namespaced_array => numbers }
+
+      cleaned[:namespaced_array].should eq(numbers)
+    end
+
     it "silently discards cast errors" do
       @params = {:num => "f"}
 
@@ -95,7 +141,7 @@ describe InputSanitizer::Sanitizer do
 
       cleaned.should have_key(:num)
       cleaned[:num].should == 23
-      cleaned[:is_nice].should be_false
+      cleaned[:is_nice].should eq(false)
     end
 
     it "overrides inherited fields" do
@@ -106,6 +152,32 @@ describe InputSanitizer::Sanitizer do
       cleaned[:is_nice].should == 42
     end
 
+    context "when sanitizer is initialized with default values" do
+      context "when paremeters are not overwriten" do
+        let(:sanitizer) { DefaultParameters.new({}) }
+
+        it "returns default value for non custom key" do
+          sanitizer.cleaned[:funky_number].should == 5
+        end
+
+        it "returns default value for custom key" do
+          sanitizer.cleaned[:fixed_stuff].should == "default string"
+        end
+      end
+
+      context "when parameters are overwriten" do
+        let(:sanitizer) { DefaultParameters.new({ :funky_number => 2, :fixed_stuff => "fixed" }) }
+
+        it "returns default value for non custom key" do
+          sanitizer.cleaned[:funky_number].should == 2
+        end
+
+        it "returns default value for custom key" do
+          sanitizer.cleaned[:fixed_stuff].should == "fixed"
+        end
+      end
+    end
+
   end
 
   describe ".custom" do
@@ -120,9 +192,53 @@ describe InputSanitizer::Sanitizer do
     end
 
     it "raises an error when converter is not defined" do
-      expect do
+      lambda do
         BrokenCustomSanitizer.custom(:x)
-      end.to raise_error
+      end.should raise_error
+    end
+
+    it "provides the converter with requested value" do
+      @params = { :custom3 => 'three', :num => 1 }
+      cleaned.should have_key(:custom3)
+      cleaned.should have_key(:num)
+      cleaned[:custom3].should eq('eerht')
+      cleaned[:num].should eq(1)
+    end
+  end
+
+  describe ".nested" do
+    let(:sanitizer) { BasicSanitizer.new(@params) }
+    let(:cleaned) { sanitizer.cleaned }
+
+    it "sanitizes nested values" do
+      nested = [
+        { :nested => { :foo => "5" } },
+        { :nested => { :foo => 8 } },
+      ]
+      @params = { :stuff => nested }
+
+      expected = [
+        { :nested => { :foo => 5 } },
+        { :nested => { :foo => 8 } },
+      ]
+      cleaned[:stuff].should eq(expected)
+    end
+
+    it "propagates errors" do
+      nested = [ { :nested => { :foo => "INVALID" } } ]
+      @params = { :stuff => nested }
+
+      sanitizer.should_not be_valid
+    end
+
+    it "returns an error when given a nil for a nested value" do
+      @params = { :stuff => nil }
+      sanitizer.should_not be_valid
+    end
+
+    it "returns an error when given a string for a nested value" do
+      @params = { :stuff => 'nope' }
+      sanitizer.should_not be_valid
     end
   end
 
@@ -131,43 +247,25 @@ describe InputSanitizer::Sanitizer do
 
     it "includes :integer type" do
       sanitizer.converters.should have_key(:integer)
-      sanitizer.converters[:integer].should be_a(InputSanitizer::IntegerConverter)
+      sanitizer.converters[:integer].should be_a(InputSanitizer::V1::IntegerConverter)
     end
 
     it "includes :string type" do
       sanitizer.converters.should have_key(:string)
-      sanitizer.converters[:string].should be_a(InputSanitizer::StringConverter)
+      sanitizer.converters[:string].should be_a(InputSanitizer::V1::StringConverter)
     end
 
     it "includes :date type" do
       sanitizer.converters.should have_key(:date)
-      sanitizer.converters[:date].should be_a(InputSanitizer::DateConverter)
+      sanitizer.converters[:date].should be_a(InputSanitizer::V1::DateConverter)
     end
 
     it "includes :boolean type" do
       sanitizer.converters.should have_key(:boolean)
-      sanitizer.converters[:boolean].should be_a(InputSanitizer::BooleanConverter)
+      sanitizer.converters[:boolean].should be_a(InputSanitizer::V1::BooleanConverter)
     end
   end
 
-  describe '.extract_options' do
-
-    it "extracts hash from array if is last" do
-      options = { :a => 1}
-      array = [1,2, options]
-      BasicSanitizer.extract_options(array).should == options
-      array.should == [1,2, options]
-    end
-
-    it "does not extract the last element if not a hash and returns default empty hash" do
-      array = [1,2]
-      BasicSanitizer.extract_options(array).should_not == 2
-      BasicSanitizer.extract_options(array).should == {}
-      array.should == [1,2]
-    end
-
-  end
-
   describe '.extract_options!' do
 
     it "extracts hash from array if is last" do
@@ -234,4 +332,9 @@ describe InputSanitizer::Sanitizer do
       error[:field].should == :c1
     end
   end
+
+  it "is valid when given extra params" do
+    @params = { :extra => 'test' }
+    sanitizer.should be_valid
+  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,22 @@
 require 'bundler'
 Bundler.setup(:test)
 
-require 'simplecov'
-SimpleCov.start unless ENV['CI'] == 'true'
+skip_coverage = ENV['CI']
+
+unless skip_coverage
+  require 'simplecov'
+  SimpleCov.start
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :should
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :should
+  end
+end
 
 require 'input_sanitizer'
+require 'pry'

data/spec/v1/default_converters_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe InputSanitizer::V1::IntegerConverter do
+  let(:converter) { InputSanitizer::V1::IntegerConverter.new }
+
+  it "casts string to integer" do
+    converter.call("42").should == 42
+  end
+
+  it "casts integer to integer" do
+    converter.call(42).should == 42
+  end
+
+  it "raises error if cannot cast" do
+    lambda { converter.call("f") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::V1::DateConverter do
+  let(:converter) { InputSanitizer::V1::DateConverter.new }
+
+  it "casts dates in iso format" do
+    converter.call("2012-05-15").should == Date.new(2012, 5, 15)
+  end
+
+  it "raises error if cannot cast" do
+    lambda { converter.call("2012-02-30") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::V1::BooleanConverter do
+  let(:converter) { InputSanitizer::V1::BooleanConverter.new }
+
+  it "casts 'true' to true" do
+    converter.call('true').should eq(true)
+  end
+
+  it "casts true to true" do
+    converter.call(true).should eq(true)
+  end
+
+  it "casts '1' to true" do
+    converter.call('1').should eq(true)
+  end
+
+  it "casts 'yes' to true" do
+    converter.call('yes').should eq(true)
+  end
+
+  it "casts 'false' to false" do
+    converter.call('false').should eq(false)
+  end
+
+  it "casts false to false" do
+    converter.call(false).should eq(false)
+  end
+
+  it "casts '0' to false" do
+    converter.call('0').should eq(false)
+  end
+
+  it "casts 'no' to false" do
+    converter.call('no').should eq(false)
+  end
+
+  it "raises error if cannot cast" do
+    lambda { converter.call("notboolean") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::V1::TimeConverter do
+  let(:converter) { InputSanitizer::V1::TimeConverter.new }
+
+  it "raises if timezone part given" do
+    lambda { converter.call("2012-05-15 13:42:54 +01:00") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "casts date time in iso format" do
+    t = Time.utc(2012, 5, 15, 13, 42, 54)
+    converter.call("2012-05-15 13:42:54").should == t
+    converter.call("2012-05-15T13:42:54").should == t
+    converter.call("20120515134254").should == t
+  end
+
+  it "works with miliseconds" do
+    t = Time.utc(2012, 5, 15, 13, 42, 54)
+    converter.call("2012-05-15 13:42:54.000").should == t
+    converter.call("2012-05-15T13:42:54.000").should == t
+    converter.call("20120515134254000").should == t
+  end
+
+  it "works with Z at the end" do
+    t = Time.utc(2012, 5, 15, 13, 42, 54)
+    converter.call("2012-05-15 13:42:54.000Z").should == t
+    converter.call("2012-05-15T13:42:54.000Z").should == t
+   converter.call("2012-05-15T13:42:54Z").should == t
+    converter.call("20120515134254000Z").should == t
+  end
+
+  it "does not require time part" do
+    converter.call("2012-05-15 13:42").should == Time.utc(2012, 5, 15, 13, 42)
+    converter.call("2012-05-15 13").should == Time.utc(2012, 5, 15, 13)
+    converter.call("2012-05-15").should == Time.utc(2012, 5, 15)
+  end
+
+  it "raises error if can format is wrong" do
+    lambda { converter.call("2/10/2031 13:44:22") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "raises error if date is wrong" do
+    lambda { converter.call("2012-02-32") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "allows the instance of Time" do
+    t = Time.now
+    converter.call(t).should == t.utc
+  end
+
+  it "raises error if value is of invalid type" do
+    lambda { converter.call({}) }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::V1::AllowNil do
+  it "passes blanks" do
+    lambda { |_| 1 }.extend(InputSanitizer::V1::AllowNil).call("").should be_nil
+  end
+
+  it "passes things the extended sanitizer passes" do
+    lambda { |_| :something }.extend(InputSanitizer::V1::AllowNil).call(:stuff).
+      should eq(:something)
+  end
+
+  it "raises error if the extended sanitizer raises error" do
+    action = lambda do
+      lambda { |_| raise "Some error" }.extend(InputSanitizer::V1::AllowNil).call(:stuff)
+    end
+
+    action.should raise_error
+  end
+end

data/spec/v2/converters_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+# OPTIONS
+# :allow_nil (default true)
+# :allow_blank (default true)
+# :require (default false, requires given key in params, and additionally sets :allow_nil and :allow_blank to false)
+
+#           | allow_nil | allow_blank
+# __________|___________|_____________
+# string    |    YES    |     YES
+# url       |    YES    |     YES
+# datetime  |    YES    |     YES
+# integer   |    YES    |     NO
+# boolean   |    NO     |     NO
+# ------------------------------------
+
+# [type, value, option] => valid? # if valid? == false then check for ValueMissing error
+
+test_cases = {
+  [InputSanitizer::V2::Types::StringCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::StringCheck, { :allow_nil => false }, ""] => true,
+  [InputSanitizer::V2::Types::StringCheck, { :allow_nil => false }, "zz"] => true,
+  [InputSanitizer::V2::Types::StringCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::StringCheck, { :allow_blank => false }, ""] => false,
+  [InputSanitizer::V2::Types::StringCheck, { :allow_blank => false }, "zz"] => true,
+  [InputSanitizer::V2::Types::StringCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::StringCheck, { :required => true }, ""] => false,
+  [InputSanitizer::V2::Types::StringCheck, { :required => true }, "zz"] => true,
+  [InputSanitizer::V2::Types::StringCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::StringCheck, { }, ""] => true,
+  [InputSanitizer::V2::Types::StringCheck, { }, "zz"] => true,
+  [InputSanitizer::V2::Types::IntegerCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::IntegerCheck, { :allow_nil => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::IntegerCheck, { :allow_nil => false }, 1] => true,
+  [InputSanitizer::V2::Types::IntegerCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::IntegerCheck, { :allow_blank => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::IntegerCheck, { :allow_blank => false }, 1] => true,
+  [InputSanitizer::V2::Types::IntegerCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::IntegerCheck, { :required => true }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::IntegerCheck, { :required => true }, 1] => true,
+  [InputSanitizer::V2::Types::IntegerCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::IntegerCheck, { }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::IntegerCheck, { }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_nil => false }, "null"] => false,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_nil => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_nil => false }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_blank => false }, "null"] => false,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_blank => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :allow_blank => false }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :required => true }, "null"] => false,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :required => true }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { :required => true }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { }, "null"] => true,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingIntegerCheck, { }, 1] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_nil => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_nil => false }, 1] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_nil => false }, 3.1415] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_blank => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_blank => false }, 1] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { :allow_blank => false }, 3.1415] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::FloatCheck, { :required => true }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::FloatCheck, { :required => true }, 1] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { :required => true }, 3.1415] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::FloatCheck, { }, 1] => true,
+  [InputSanitizer::V2::Types::FloatCheck, { }, 3.1415] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_nil => false }, "null"] => false,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_nil => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_nil => false }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_nil => false }, 3.1415] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_nil => false }, "3.1415"] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_blank => false }, "null"] => false,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_blank => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_blank => false }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_blank => false }, 3.1415] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :allow_blank => false }, "3.1415"] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :required => true }, "null"] => false,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :required => true }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :required => true }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :required => true }, 3.1415] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { :required => true }, "3.1415"] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { }, "null"] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { }, 1] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { }, 3.1415] => true,
+  [InputSanitizer::V2::Types::CoercingFloatCheck, { }, "3.1415"] => true,
+  [InputSanitizer::V2::Types::BooleanCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::BooleanCheck, { :allow_nil => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::BooleanCheck, { :allow_nil => false }, true] => true,
+  [InputSanitizer::V2::Types::BooleanCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::BooleanCheck, { :allow_blank => false }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::BooleanCheck, { :allow_blank => false }, true] => true,
+  [InputSanitizer::V2::Types::BooleanCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::BooleanCheck, { :required => true }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::BooleanCheck, { :required => true }, true] => true,
+  [InputSanitizer::V2::Types::BooleanCheck, { }, nil] => false,
+  [InputSanitizer::V2::Types::BooleanCheck, { }, ""] => :invalid_type,
+  [InputSanitizer::V2::Types::BooleanCheck, { }, true] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :allow_nil => false }, ""] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :allow_nil => false }, "2014-08-27T16:32:56Z"] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :allow_blank => false }, ""] => false,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :allow_blank => false }, "2014-08-27T16:32:56Z"] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :required => true }, ""] => false,
+  [InputSanitizer::V2::Types::DatetimeCheck, { :required => true }, "2014-08-27T16:32:56Z"] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { }, ""] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { }, "2014-08-27T16:32:56Z"] => true,
+  [InputSanitizer::V2::Types::DatetimeCheck, { }, 1234] => :invalid_type,
+  [InputSanitizer::V2::Types::DatetimeCheck, { }, []] => :invalid_type,
+  [InputSanitizer::V2::Types::DatetimeCheck, { }, {}] => :invalid_type,
+  [InputSanitizer::V2::Types::URLCheck, { :allow_nil => false }, nil] => false,
+  [InputSanitizer::V2::Types::URLCheck, { :allow_nil => false }, ""] => true,
+  [InputSanitizer::V2::Types::URLCheck, { :allow_nil => false }, "http://getbase.com"] => true,
+  [InputSanitizer::V2::Types::URLCheck, { :allow_blank => false }, nil] => false,
+  [InputSanitizer::V2::Types::URLCheck, { :allow_blank => false }, ""] => false,
+  [InputSanitizer::V2::Types::URLCheck, { :allow_blank => false }, "http://getbase.com"] => true,
+  [InputSanitizer::V2::Types::URLCheck, { :required => true }, nil] => false,
+  [InputSanitizer::V2::Types::URLCheck, { :required => true }, ""] => false,
+  [InputSanitizer::V2::Types::URLCheck, { :required => true }, "http://getbase.com"] => true,
+  [InputSanitizer::V2::Types::URLCheck, { }, nil] => true,
+  [InputSanitizer::V2::Types::URLCheck, { }, ""] => true,
+  [InputSanitizer::V2::Types::URLCheck, { }, "http://getbase.com"] => true,
+}
+
+describe 'type checks' do
+  test_cases.each do |(test_case, result)|
+    describe test_case[0] do
+      context "with options: #{test_case[1]}" do
+        show_value = case test_case[2]
+        when nil then 'nil'
+        when '' then "''"
+        else "'#{test_case[2]}'"
+        end
+
+        it "correctly handles value #{show_value}" do
+          case result
+          when true
+            lambda { test_case[0].new.call(test_case[2], test_case[1]) }.should_not raise_error
+          when false
+            lambda { test_case[0].new.call(test_case[2], test_case[1]) }.should raise_error(InputSanitizer::BlankValueError)
+          when :invalid_type
+            lambda { test_case[0].new.call(test_case[2], test_case[1]) }.should raise_error(InputSanitizer::TypeMismatchError)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Generating test cases:
+
+# types = ['string', 'integer', 'boolean', 'datetime', 'url']
+# options = [:allow_nil_false, :allow_blank_false, :required_true, :no_params]
+# values = [nil, '', lambda { |type| { 'string' => 'zz', 'integer' => 1, 'boolean' => true, 'datetime' => '2014-08-27T16:32:56Z', 'url' => 'http://getbase.com' }[type] }]
+# test_cases = types.product(options).product(values).map(&:flatten).map! do |test_case|
+#   test_case[2] = test_case[2].call(test_case[0]) if test_case[2].is_a?(Proc); test_case
+# end
+# test_cases.each { |test_case| puts "#{test_case.inspect} => []," }; nil