input_sanitizer 0.2.2 → 0.3.33

data/lib/input_sanitizer/v2.rb

@@ -0,0 +1,13 @@
+module InputSanitizer::V2
+end
+
+dir = File.dirname(__FILE__)
+require File.join(dir, 'v2/types')
+require File.join(dir, 'v2/clean_payload_collection_field')
+require File.join(dir, 'v2/clean_query_collection_field')
+require File.join(dir, 'v2/clean_field')
+require File.join(dir, 'v2/nested_sanitizer_factory')
+require File.join(dir, 'v2/error_collection')
+require File.join(dir, 'v2/payload_sanitizer')
+require File.join(dir, 'v2/query_sanitizer')
+require File.join(dir, 'v2/payload_transform')

data/lib/input_sanitizer/version.rb

@@ -1,3 +1,3 @@
 module InputSanitizer
-  VERSION = "0.2.2"
+  VERSION = "0.3.33"
 end

data/lib/input_sanitizer.rb

@@ -1,5 +1,8 @@
 module InputSanitizer
 end
 
-require "input_sanitizer/version"
-require 'input_sanitizer/sanitizer'
+require 'method_struct'
+
+require 'input_sanitizer/version'
+require 'input_sanitizer/v1'
+require 'input_sanitizer/v2'

data/spec/extended_converters/comma_joined_integers_converter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'input_sanitizer/extended_converters/comma_joined_integers_converter'
+
+describe InputSanitizer::CommaJoinedIntegersConverter do
+  let(:converter) { described_class.new }
+
+  it "parses to array of ids" do
+    converter.call("1,2,3,5").should eq([1, 2, 3, 5])
+  end
+
+  it "converts to array if given an integer" do
+    converter.call(7).should eq([7])
+  end
+
+  it "raises on invalid character" do
+    lambda { converter.call(":") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end

data/spec/extended_converters/comma_joined_strings_converter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'input_sanitizer/extended_converters/comma_joined_strings_converter'
+
+describe InputSanitizer::CommaJoinedStringsConverter do
+  let(:converter) { described_class.new }
+
+  it "parses to array of ids" do
+    converter.call("input,Sanitizer,ROCKS").should eq(["input", "Sanitizer", "ROCKS"])
+  end
+
+  it "allows underscores" do
+    converter.call("input_sanitizer,rocks").should eq(["input_sanitizer", "rocks"])
+  end
+
+  it "raises on invalid character" do
+    lambda { converter.call(":") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end

data/spec/extended_converters/positive_integer_converter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'input_sanitizer/extended_converters/positive_integer_converter'
+
+describe InputSanitizer::PositiveIntegerConverter do
+  let(:converter) { described_class.new }
+
+  it "casts string to integer" do
+    converter.call("3").should == 3
+  end
+
+  it "raises error if integer less than zero" do
+    lambda { converter.call("-3") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "raises error if integer equals zero" do
+    lambda { converter.call("0") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end

data/spec/extended_converters/specific_values_converter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'input_sanitizer/extended_converters/specific_values_converter'
+
+describe InputSanitizer::SpecificValuesConverter do
+  let(:converter) { described_class.new(values) }
+  let(:values) { [:a, :b] }
+
+  it "converts valid value to symbol" do
+    converter.call("b").should eq(:b)
+  end
+
+  it "raises on invalid value" do
+    lambda { converter.call("c") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "raises on nil value" do
+    lambda { converter.call(nil) }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  context "when specific values are strings" do
+    let(:values) { ["a", "b"] }
+
+    it "keeps given value as string" do
+      converter.call("a").should eq("a")
+    end
+  end
+end

data/spec/restricted_hash_spec.rb

@@ -1,19 +1,49 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe InputSanitizer::RestrictedHash do
-  let(:hash) { InputSanitizer::RestrictedHash.new([:a, :b]) }
-  subject { hash }
+  let(:hash) { InputSanitizer::RestrictedHash.new([:a]) }
 
-  it "does not allow bad keys" do
-    lambda{hash[:c]}.should raise_error(InputSanitizer::KeyNotAllowedError)
+  it 'does not allow bad keys' do
+    lambda{ hash[:b] }.should raise_error(InputSanitizer::KeyNotAllowedError)
   end
 
-  it "does allow correct keys" do
+  it 'does allow correct keys' do
     hash[:a].should be_nil
   end
 
-  it "returns value for correct key" do
+  it 'returns value for correct key' do
     hash[:a] = 'stuff'
     hash[:a].should == 'stuff'
   end
+
+  it 'allows to set value for a new key' do
+    hash[:b] = 'other stuff'
+    hash[:b].should == 'other stuff'
+    hash.key_allowed?(:b).should be_truthy
+  end
+
+  it 'adds new allowed keys after `transform_keys` is done' do
+    hash[:a] = 'stuff'
+    hash.transform_keys! { |key| key.to_s }
+    hash['a'].should == 'stuff'
+    hash.key_allowed?('a').should be_truthy
+  end
+
+  it 'removes previous allowed keys after `transform_keys` is done' do
+    hash[:a] = 'stuff'
+    hash.transform_keys! { |key| key.to_s }
+    lambda{ hash[:a] }.should raise_error(InputSanitizer::KeyNotAllowedError)
+  end
+
+  it 'updates allowed keys on merge!' do
+    merge_hash = { merged: '1' }
+    hash.merge!(merge_hash)
+    hash.key_allowed?(:merged).should be_truthy
+  end
+
+  it 'updates allowed keys on merge' do
+    merge_hash = { merged: '1' }
+    new_hash = hash.merge(some_key: merge_hash)
+    new_hash.key_allowed?(:some_key).should be_truthy
+  end
 end

data/spec/sanitizer_spec.rb

@@ -73,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 = {}
 
@@ -217,6 +223,23 @@ describe InputSanitizer::Sanitizer do
       ]
       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
 
   describe ".converters" do
@@ -224,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
@@ -327,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,9 @@
 require 'bundler'
 Bundler.setup(:test)
 
-unless ENV['CI']
+skip_coverage = ENV['CI'] || RUBY_VERSION =~ /^1\.8/
+
+unless skip_coverage
   require 'simplecov'
   SimpleCov.start
 end

data/spec/{default_converters_spec.rb → v1/default_converters_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe InputSanitizer::IntegerConverter do
-  let(:converter) { InputSanitizer::IntegerConverter.new }
+describe InputSanitizer::V1::IntegerConverter do
+  let(:converter) { InputSanitizer::V1::IntegerConverter.new }
 
   it "casts string to integer" do
     converter.call("42").should == 42
@@ -16,8 +16,8 @@ describe InputSanitizer::IntegerConverter do
   end
 end
 
-describe InputSanitizer::DateConverter do
-  let(:converter) { InputSanitizer::DateConverter.new }
+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)
@@ -28,8 +28,8 @@ describe InputSanitizer::DateConverter do
   end
 end
 
-describe InputSanitizer::BooleanConverter do
-  let(:converter) { InputSanitizer::BooleanConverter.new }
+describe InputSanitizer::V1::BooleanConverter do
+  let(:converter) { InputSanitizer::V1::BooleanConverter.new }
 
   it "casts 'true' to true" do
     converter.call('true').should eq(true)
@@ -68,9 +68,8 @@ describe InputSanitizer::BooleanConverter do
   end
 end
 
-
-describe InputSanitizer::TimeConverter do
-  let(:converter) { InputSanitizer::TimeConverter.new }
+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)
@@ -121,3 +120,22 @@ describe InputSanitizer::TimeConverter 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