duck-hunt 0.0.3

data/test/properties/nil_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe DuckHunt::Properties::Nil, "validation" do
+  before do
+    @property = DuckHunt::Properties::Nil.new
+  end
+
+  it "should be able to validate a nil value" do
+    @property.valid?(nil).must_equal true
+    @property.errors.size.must_equal 0
+  end
+
+  it "should be invalid if the value is not nil" do
+    @property.valid?([1,2,3]).must_equal false
+    @property.errors.size.must_equal 1
+    @property.errors.first.must_equal "wrong type"
+  end
+
+  it "should not be able to validate a string representing nil" do
+    @property.valid?("nil").must_equal false
+    @property.errors.size.must_equal 1
+    @property.errors.first.must_equal "wrong type"
+  end
+
+  it "should not be able to validate the integer 'representation' of a nil" do
+    @property.valid?(0).must_equal false
+    @property.errors.size.must_equal 1
+    @property.errors.first.must_equal "wrong type"
+  end
+end

data/test/properties/property_test.rb

@@ -0,0 +1,193 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe DuckHunt::Properties::Property, "initialization" do
+  it "should make the property required by default" do
+    property = DuckHunt::Properties::Property.new
+    property.required.must_equal true
+    property.required?.must_equal true
+  end
+
+  it "should not allow nil objects by default" do
+    property = DuckHunt::Properties::Property.new
+    property.allow_nil.must_equal false
+    property.allow_nil?.must_equal false
+  end
+
+  it "allow the requiredness to be changed via the options hash" do
+    property = DuckHunt::Properties::Property.new(:required => false)
+    property.required.must_equal false
+    property.required?.must_equal false
+
+    property = DuckHunt::Properties::Property.new(:required => true)
+    property.required.must_equal true
+    property.required?.must_equal true
+  end
+end
+
+describe DuckHunt::Properties::Property, "validation" do
+  it "should be invalid if there's a type mismatch" do
+    property = DuckHunt::Properties::Property.new
+    property.stubs(:matches_type?).returns(false)
+
+    property.valid?("herp").must_equal false
+    property.errors.size.must_equal 1
+    property.errors.first.must_equal "wrong type"
+  end
+
+  it "should not call the validators when there is a type mismatch" do
+    property = DuckHunt::Properties::Property.new(:always_wrong => true)
+    property.stubs(:matches_type?).returns(false)
+
+    property.valid?("herp").must_equal false
+    property.errors.size.must_equal 1
+    property.errors.first.must_equal "wrong type"
+  end
+
+  it "should raise an exception if a validator raises an exception, since this is the clearest way to indicate the schema was not defined correctly" do
+    property = DuckHunt::Properties::Property.new(:always_raise_exception => true)
+    property.stubs(:matches_type?).returns(true)
+
+    lambda{
+      property.valid?("herp")
+    }.must_raise Exception
+  end
+
+  it "should use a validator defined during initialization when validating" do
+    property = DuckHunt::Properties::Property.new(:always_wrong => true)
+    property.stubs(:matches_type?).returns(true)
+    property.valid?("herp").must_equal false
+    property.errors.size.must_equal 1
+    property.errors.first.must_equal "Always Wrong"
+  end
+
+  it "should support adding multiple validators during initialization" do
+    property = DuckHunt::Properties::Property.new(:always_wrong => true, :wrong_again => true)
+    property.stubs(:matches_type?).returns(true)
+    property.valid?("herp").must_equal false
+    property.errors.size.must_equal 2
+    property.errors.to_set.must_equal ["Always Wrong", "Wrong Again"].to_set
+  end
+
+  it "should be valid if the type matches and no validators are added" do
+    property = DuckHunt::Properties::Property.new
+    property.stubs(:matches_type?).returns(true)
+
+    property.valid?("herp").must_equal true
+    property.errors.size.must_equal 0
+  end
+
+  it "should be valid if the type matches and all validators pass" do
+    property = DuckHunt::Properties::Property.new(:always_right => true, :right_again => true)
+    property.stubs(:matches_type?).returns(true)
+
+    property.valid?("herp").must_equal true
+    property.errors.size.must_equal 0
+  end
+
+  it "should be valid if a nil object is allowed and a nil object is provided" do
+    property = DuckHunt::Properties::Property.new(:allow_nil => true)
+    property.valid?(nil).must_equal true
+    property.errors.size.must_equal 0
+  end
+
+  it "should be valid if a nil object is allowed and a nil object is provided, even if there are other validators that would be invalidated" do
+    property = DuckHunt::Properties::Property.new(:allow_nil => true, :always_wrong => true)
+    property.valid?(nil).must_equal true
+    property.errors.size.must_equal 0
+  end
+
+  it "should be invalid if a nil object is provided and nil objects are not allowed" do
+    property = DuckHunt::Properties::Property.new(:allow_nil => false)
+    property.valid?(nil).must_equal false
+    property.errors.size.must_equal 1
+    property.errors.first.must_equal "nil object not allowed"
+  end
+
+  it "should be valid if the type matches and all validators pass (even if a nil object is allowed)" do
+    property = DuckHunt::Properties::Property.new(:allow_nil => true, :always_right => true)
+    property.stubs(:matches_type?).returns(true)
+    property.valid?("hello").must_equal true
+    property.errors.size.must_equal 0
+  end
+
+  it "should add the 'required' error message if requested" do
+    property = DuckHunt::Properties::Property.new
+    property.add_required_error
+    property.errors.size.must_equal 1
+    property.errors.first.must_equal "required"
+  end
+
+  it "should raise NotImplementedError if `matches_type?` has not been defined (subclasses define it)" do
+    property = DuckHunt::Properties::Property.new
+    lambda{
+      property.valid?("hello")
+    }.must_raise(NotImplementedError)
+  end
+end
+
+describe DuckHunt::Properties::Property, "validating multiple times" do
+  before do
+    @property = DuckHunt::Properties::Property.new
+    @property.stubs(:matches_type?).returns(true)
+  end
+
+  it "should ensure that the errors are cleared out each time `valid?` is called" do
+    @property.stubs(:matches_type?).returns(false)
+    @property.valid?("herp")
+    @property.errors.size.must_equal 1
+
+    @property.stubs(:matches_type?).returns(true)
+    @property.valid?("herp")
+    @property.errors.size.must_equal 0
+  end
+
+  it "should ensure that a property can go from valid to invalid" do
+    @property.valid?("herp").must_equal true
+    @property.errors.size.must_equal 0
+
+    @property.stubs(:matches_type?).returns(false)
+    @property.valid?("herp").must_equal false
+    @property.errors.size.must_equal 1
+  end
+
+  it "should ensure that a property can go from invalid to valid" do
+    @property.stubs(:matches_type?).returns(false)
+    @property.valid?("herp").must_equal false
+    @property.errors.size.must_equal 1
+
+    @property.stubs(:matches_type?).returns(true)
+    @property.valid?("herp").must_equal true
+    @property.errors.size.must_equal 0
+  end
+
+  it "should not add the required message twice" do
+    @property.stubs(:matches_type?).returns(false)
+    @property.add_required_error
+    @property.add_required_error
+    @property.errors.size.must_equal 1
+    @property.errors.must_equal ["required"]
+  end
+end
+
+describe DuckHunt::Properties::Property, "security" do
+  it "should ensure the required status cannot be modified" do
+    property = DuckHunt::Properties::Property.new(:required => true)
+    lambda{
+      property.required = false
+    }.must_raise(NoMethodError)
+
+    property.required.must_equal true
+  end
+
+  it "should ensure the list of validators cannot be accessed or modified" do
+    property = DuckHunt::Properties::Property.new
+
+    lambda{
+      property.validators["malicious"] = "muwah ha ha"
+    }.must_raise(NoMethodError)
+
+    lambda{
+      property.validators = {:malicious => "mwuah ha ha"}
+    }.must_raise(NoMethodError)
+  end
+end

data/test/properties/string_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe DuckHunt::Properties::String, "validation" do
+  before do
+    @property = DuckHunt::Properties::String.new
+  end
+
+  it "should be able to validate a string" do
+    @property.valid?("herpderp").must_equal true
+    @property.errors.size.must_equal 0
+  end
+
+  it "should be invalid if there's a type mismatch" do
+    @property.valid?([1,2,3]).must_equal false
+    @property.errors.size.must_equal 1
+    @property.errors.first.must_equal "wrong type"
+  end
+
+  it "should not be able to validate a symbol" do
+    @property.valid?(:test).must_equal false
+    @property.errors.size.must_equal 1
+    @property.errors.first.must_equal "wrong type"
+  end
+end

data/test/properties/validator_lookup_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class ValidatorLookupTestClass
+  include DuckHunt::Properties::ValidatorLookup
+
+  def add(name)
+    find_and_create_validator(name, true)
+  end
+end
+
+describe DuckHunt::Properties::ValidatorLookup, "Adding a validator to the property" do
+  it "should raise a `NotImplementedError` if the validator definition exists (classes using this module must implement `add_validator`" do
+    property = ValidatorLookupTestClass.new
+    lambda {
+      property.add("test")
+    }.must_raise(NotImplementedError)
+  end
+
+  it "should raise Name if the validator definition does not exist (it was not found)" do
+    property = ValidatorLookupTestClass.new
+    lambda {
+      property.add("herp")
+    }.must_raise(NameError)
+  end
+end

data/test/schemas/array_schema_test.rb

@@ -0,0 +1,797 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe DuckHunt::Schemas::ArraySchema, "defining an object through a block" do
+  it "should be able to define a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.integer
+    end
+
+    schema.single_type_property.must_be_instance_of DuckHunt::Properties::Integer
+    schema.tuple_properties.must_be_nil
+    schema.optional_tuple_properties.must_be_nil
+  end
+
+  it "should be able to define a tuple array with no optional items" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.integer
+      end
+    end
+
+    schema.tuple_properties.size.must_equal 1
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.integer
+        x.test
+      end
+    end
+
+    schema.tuple_properties.size.must_equal 2
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+    schema.tuple_properties.last.must_be_instance_of DuckHunt::Properties::Test
+  end
+
+  it "should be able to define a tuple array with optional items" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.integer
+      end
+
+      s.optional_items do |y|
+        y.integer
+        y.test
+      end
+    end
+
+    schema.tuple_properties.size.must_equal 1
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+
+    schema.optional_tuple_properties.size.must_equal 2
+    schema.optional_tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+    schema.optional_tuple_properties.last.must_be_instance_of DuckHunt::Properties::Test
+
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.integer
+        x.test
+      end
+
+      s.optional_items do |x|
+        x.integer
+      end
+    end
+
+    schema.tuple_properties.size.must_equal 2
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+    schema.tuple_properties.last.must_be_instance_of DuckHunt::Properties::Test
+
+    schema.optional_tuple_properties.size.must_equal 1
+    schema.optional_tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+  end
+
+  it "should not allow single-type and tuple definitions in the same schema" do
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.define do |s|
+        s.integer
+        s.items do |x|
+          x.integer
+        end
+      end
+    }.must_raise DuckHunt::InvalidSchema
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.define do |s|
+        s.items do |x|
+          x.integer
+        end
+        s.integer
+      end
+    }.must_raise DuckHunt::InvalidSchema
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.define do |s|
+        s.integer
+        s.optional_items do |x|
+          x.integer
+        end
+      end
+    }.must_raise DuckHunt::InvalidSchema
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.define do |s|
+        s.optional_items do |x|
+          x.integer
+        end
+        s.integer
+      end
+    }.must_raise DuckHunt::InvalidSchema
+  end
+
+  it "should pass a block down to the property that defines a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.test_block_passed {1+1}
+    end
+
+    schema.single_type_property.block_passed.must_equal true
+  end
+
+  it "should pass a block down to the properties in a tuple array" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.test_block_passed {1+1}
+      end
+
+      s.optional_items do |y|
+        y.test_block_passed {1+1}
+      end
+    end
+
+    schema.tuple_properties.first.block_passed.must_equal true
+    schema.optional_tuple_properties.first.block_passed.must_equal true
+  end
+
+  it "should require that a block be passed when setting tuple properties" do
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.define do |s|
+        s.items
+      end
+    }.must_raise ArgumentError
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.define do |s|
+        s.optional_items
+      end
+    }.must_raise ArgumentError
+  end
+
+  it "should allow the uniqueness flag to be set during initialization" do
+    schema = DuckHunt::Schemas::ArraySchema.define :validates_uniqueness => true do |s|
+      s.integer
+    end
+
+    schema.validates_uniqueness?.must_equal true
+    schema.validates_uniqueness.must_equal true
+  end
+
+  it "should allow the min and max size to be set during initialization" do
+    schema = DuckHunt::Schemas::ArraySchema.define :min_size => 10 do |s|
+      s.integer
+    end
+
+    schema.min_size.must_equal 10
+    schema.max_size.must_be_nil
+
+    schema = DuckHunt::Schemas::ArraySchema.define :max_size => 10 do |s|
+      s.integer
+    end
+
+    schema.min_size.must_be_nil
+    schema.max_size.must_equal 10
+
+    schema = DuckHunt::Schemas::ArraySchema.define :min_size => 5, :max_size => 10 do |s|
+      s.integer
+    end
+
+    schema.min_size.must_equal 5
+    schema.max_size.must_equal 10
+  end
+
+  it "should allow the 'allow nil' flag to be set during initialization" do
+    schema = DuckHunt::Schemas::ArraySchema.define :allow_nil => true do |s|
+      s.integer
+    end
+
+    schema.allow_nil.must_equal true
+    schema.allow_nil?.must_equal true
+  end
+
+  it "should default the uniqueness flag to false" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.integer
+    end
+
+    schema.validates_uniqueness.must_equal false
+    schema.validates_uniqueness?.must_equal false
+  end
+
+  it "should default the min and max size to nil" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.integer
+    end
+
+    schema.min_size.must_be_nil
+    schema.max_size.must_be_nil
+  end
+
+  it "should default the 'allow nil' flag to false" do
+    schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.integer
+    end
+
+    schema.allow_nil.must_equal false
+    schema.allow_nil?.must_equal false
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "defining an object without a block" do
+  it "should be able to define a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.integer
+
+    schema.single_type_property.must_be_instance_of DuckHunt::Properties::Integer
+    schema.tuple_properties.must_be_nil
+    schema.optional_tuple_properties.must_be_nil
+  end
+
+  it "should be able to define a tuple array with no optional items" do
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.items do |x|
+      x.integer
+    end
+
+    schema.tuple_properties.size.must_equal 1
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.items do |x|
+      x.integer
+      x.test
+    end
+
+    schema.tuple_properties.size.must_equal 2
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+    schema.tuple_properties.last.must_be_instance_of DuckHunt::Properties::Test
+  end
+
+  it "should be able to define a tuple array with optional items" do
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.items do |x|
+      x.integer
+    end
+
+    schema.optional_items do |y|
+      y.integer
+      y.test
+    end
+
+    schema.tuple_properties.size.must_equal 1
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+
+    schema.optional_tuple_properties.size.must_equal 2
+    schema.optional_tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+    schema.optional_tuple_properties.last.must_be_instance_of DuckHunt::Properties::Test
+
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.items do |x|
+      x.integer
+      x.test
+    end
+
+    schema.optional_items do |x|
+      x.integer
+    end
+
+    schema.tuple_properties.size.must_equal 2
+    schema.tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+    schema.tuple_properties.last.must_be_instance_of DuckHunt::Properties::Test
+
+    schema.optional_tuple_properties.size.must_equal 1
+    schema.optional_tuple_properties.first.must_be_instance_of DuckHunt::Properties::Integer
+  end
+
+  it "should not allow single-type and tuple definitions in the same schema" do
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.new
+      schema.integer
+      schema.items do |x|
+        x.integer
+      end
+    }.must_raise DuckHunt::InvalidSchema
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.new
+      schema.items do |x|
+        x.integer
+      end
+      schema.integer
+    }.must_raise DuckHunt::InvalidSchema
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.new
+      schema.integer
+      schema.optional_items do |x|
+        x.integer
+      end
+    }.must_raise DuckHunt::InvalidSchema
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.new
+      schema.optional_items do |x|
+        x.integer
+      end
+      schema.integer
+    }.must_raise DuckHunt::InvalidSchema
+  end
+
+  it "should require that a block be passed when setting tuple properties" do
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.new
+      schema.items
+    }.must_raise ArgumentError
+
+    lambda{
+      schema = DuckHunt::Schemas::ArraySchema.new
+      schema.optional_items
+    }.must_raise ArgumentError
+  end
+
+  it "should allow the uniqueness flag to be set during initialization" do
+    schema = DuckHunt::Schemas::ArraySchema.new(:validates_uniqueness => true)
+    schema.integer
+
+    schema.validates_uniqueness?.must_equal true
+    schema.validates_uniqueness.must_equal true
+  end
+
+  it "should allow the min and max size to be set during initialization" do
+    schema = DuckHunt::Schemas::ArraySchema.new(:min_size => 10)
+    schema.integer
+
+    schema.min_size.must_equal 10
+    schema.max_size.must_be_nil
+
+    schema = DuckHunt::Schemas::ArraySchema.new :max_size => 10
+    schema.integer
+
+    schema.min_size.must_be_nil
+    schema.max_size.must_equal 10
+
+    schema = DuckHunt::Schemas::ArraySchema.new :min_size => 5, :max_size => 10
+    schema.integer
+
+    schema.min_size.must_equal 5
+    schema.max_size.must_equal 10
+  end
+
+  it "should allow the 'allow nil' flag to be set during initialization" do
+    schema = DuckHunt::Schemas::ArraySchema.new(:allow_nil => true)
+    schema.integer
+
+    schema.allow_nil.must_equal true
+    schema.allow_nil?.must_equal true
+  end
+
+  it "should default the uniqueness flag to false" do
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.integer
+
+    schema.validates_uniqueness.must_equal false
+    schema.validates_uniqueness?.must_equal false
+  end
+
+  it "should default the min and max size to nil" do
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.integer
+
+    schema.min_size.must_be_nil
+    schema.max_size.must_be_nil
+  end
+
+  it "should default the 'allow nil' flag to false" do
+    schema = DuckHunt::Schemas::ArraySchema.new
+    schema.integer
+
+    schema.allow_nil.must_equal false
+    schema.allow_nil?.must_equal false
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "single-type validation" do
+  before do
+    @schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.integer
+    end
+  end
+
+  it "should return false if the object provided is not an array" do
+    @schema.validate?("hello").must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["wrong type"]
+  end
+
+  it "should return true if there are no entries in the array" do
+    @schema.validate?([]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if every entry in the array is of the correct type" do
+    @schema.validate?([1,2,3]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return false if any entry in the array is not of the correct type, and have a base error mesage" do
+    @schema.validate?([1,"boo",3]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["1"].must_equal ["wrong type"]
+  end
+
+  it "should empty the errors array each time we validate" do
+    @schema.validate?([1,"boo",3]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["1"].must_equal ["wrong type"]
+
+    @schema.validate?(["boo",2,3]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["0"].must_equal ["wrong type"]
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "tuple validation (no optional items)" do
+  before do
+    @schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.always_right_type
+        x.integer
+      end
+    end
+  end
+
+  it "should return false if the object provided is not an array" do
+    @schema.validate?("hello").must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["wrong type"]
+  end
+
+  it "should return false if there are no items in the array" do
+    @schema.validate?([]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 2 item(s) but got 0 item(s)"]
+  end
+
+  it "should return false if there are fewer items in the array than what is defined in the tuple" do
+    @schema.validate?([1]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 2 item(s) but got 1 item(s)"]
+  end
+
+  it "should return false if there are more items in the array than what is defined in the tuple" do
+    @schema.validate?([1,2,3]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at most 2 item(s) but got 3 item(s)"]
+  end
+
+  it "should return false if any of the items are not the correct type specified for that index" do
+    @schema.validate?([1, "hello"]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["1"].must_equal ["wrong type"]
+  end
+
+  it "should return true if the items in the array match their defined type" do
+    @schema.validate?([1, 2]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should empty the errors array each time we validate" do
+    @schema.validate?([1, "hello"]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["1"].must_equal ["wrong type"]
+
+    @schema.validate?([1]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 2 item(s) but got 1 item(s)"]
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "tuple validation (with optional items)" do
+  before do
+    @schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.items do |x|
+        x.always_right_type
+        x.integer
+      end
+
+      s.optional_items do |y|
+        y.integer
+        y.always_right_type
+      end
+    end
+  end
+
+  it "should return false if there are no items in the array" do
+    @schema.validate?([]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 2 item(s) but got 0 item(s)"]
+  end
+
+  it "should return false if there are fewer items in the array than what is defined in the tuple" do
+    @schema.validate?([1]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 2 item(s) but got 1 item(s)"]
+  end
+
+  it "should return true if we have extended beyond the required tuple items and into the optional items" do
+    @schema.validate?([1,2,3,4]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return false if there are more items in the array than what is defined in the tuple (including the optional items)" do
+    @schema.validate?([1,2,3,4,5]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at most 4 item(s) but got 5 item(s)"]
+  end
+
+  it "should return false if any of the required items are not the correct type specified for that index" do
+    @schema.validate?([1, "hello"]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["1"].must_equal ["wrong type"]
+  end
+
+  it "should return false if any of the optional items are not the correct type specified for that index" do
+    @schema.validate?([1,2,"hello"]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["2"].must_equal ["wrong type"]
+  end
+
+  it "should return true if the items in the array match their defined type" do
+    @schema.validate?([1,2,3,4]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if we only have the required items in the array" do
+    @schema.validate?([1,2]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if we only have some of the optional items in the array" do
+    @schema.validate?([1,2,3]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should empty the errors array each time we validate" do
+    @schema.validate?([1, "hello"]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["1"].must_equal ["wrong type"]
+
+    @schema.validate?([1]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 2 item(s) but got 1 item(s)"]
+
+    @schema.validate?([1,2,"hello"]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["2"].must_equal ["wrong type"]
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "tuple validation (all optional items)" do
+  before do
+    @schema = DuckHunt::Schemas::ArraySchema.define do |s|
+      s.optional_items do |y|
+        y.integer
+        y.always_right_type
+      end
+    end
+  end
+
+  it "should return true if there are no items in the array" do
+    @schema.validate?([]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if there are fewer items in the array than what is defined in the tuple" do
+    @schema.validate?([1]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return false if there are more items in the array than what is defined in the tuple" do
+    @schema.validate?([1,2,3]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at most 2 item(s) but got 3 item(s)"]
+  end
+
+  it "should return false if any of the items are not the correct type specified for that index" do
+    @schema.validate?(["hello",2]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["0"].must_equal ["wrong type"]
+  end
+
+  it "should return true if the items in the array match their defined type" do
+    @schema.validate?([1,2]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if we only have some of the optional items in the array" do
+    @schema.validate?([1]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should empty the errors array each time we validate" do
+    @schema.validate?(["hello",2]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["0"].must_equal ["wrong type"]
+
+    @schema.validate?([1,2,3]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at most 2 item(s) but got 3 item(s)"]
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "validating uniqueness" do
+  it "should return false if there were duplicates in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :validates_uniqueness => true do |s|
+      s.integer
+    end
+
+    schema.validate?([1,2,1]).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["duplicate items are not allowed"]
+  end
+
+  it "should return false if there were duplicates in a tuple array (no optional items)" do
+    schema = DuckHunt::Schemas::ArraySchema.define :validates_uniqueness => true do |s|
+      s.items do |x|
+        x.integer
+        x.integer
+        x.integer
+      end
+    end
+
+    schema.validate?([1,2,1]).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["duplicate items are not allowed"]
+  end
+
+  it "should return false if there were duplicates in a tuple array (with optional items)" do
+    schema = DuckHunt::Schemas::ArraySchema.define :validates_uniqueness => true do |s|
+      s.items do |x|
+        x.integer
+        x.integer
+      end
+
+      s.optional_items do |x|
+        x.integer
+      end
+    end
+
+    schema.validate?([1,2,1]).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["duplicate items are not allowed"]
+  end
+
+  it "should return false if there were duplicates in a tuple array (all optional items)" do
+    schema = DuckHunt::Schemas::ArraySchema.define :validates_uniqueness => true do |s|
+      s.optional_items do |x|
+        x.integer
+        x.integer
+        x.integer
+      end
+    end
+
+    schema.validate?([1,2,1]).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["duplicate items are not allowed"]
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "validating minimum size" do
+  it "should return false if there were not enough items in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :min_size => 3 do |s|
+      s.integer
+    end
+
+    schema.validate?([1,2]).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["expected at least 3 item(s) but got 2 item(s)"]
+  end
+
+  it "should return true if there were just enough items in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :min_size => 3 do |s|
+      s.integer
+    end
+
+    schema.validate?([1,2,3]).must_equal true
+    schema.errors.size.must_equal 0
+  end
+
+  it "should return true if there were more than enough items in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :min_size => 3 do |s|
+      s.integer
+    end
+
+    schema.validate?([1,2,3,4]).must_equal true
+    schema.errors.size.must_equal 0
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "validating maximum size" do
+  it "should return false if there were too many items in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :max_size => 3 do |s|
+      s.integer
+    end
+
+    schema.validate?([1,2,3,4]).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["expected at most 3 item(s) but got 4 item(s)"]
+  end
+
+  it "should return true if we were at the limit of items in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :max_size => 3 do |s|
+      s.integer
+    end
+
+    schema.validate?([1,2,3]).must_equal true
+    schema.errors.size.must_equal 0
+  end
+
+  it "should return true if we were not close to the limit in a single-type array" do
+    schema = DuckHunt::Schemas::ArraySchema.define :max_size => 3 do |s|
+      s.integer
+    end
+
+    schema.validate?([1]).must_equal true
+    schema.errors.size.must_equal 0
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "validating minimum and maximum size" do
+  before do
+    @schema = DuckHunt::Schemas::ArraySchema.define :min_size => 3, :max_size => 5 do |s|
+      s.integer
+    end
+  end
+
+  it "should return false if it is below the minimum" do
+    @schema.validate?([1,2]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at least 3 item(s) but got 2 item(s)"]
+  end
+
+  it "should return false if it is above the maximum" do
+    @schema.validate?([1,2,3,4,5,6]).must_equal false
+    @schema.errors.size.must_equal 1
+    @schema.errors["base"].must_equal ["expected at most 5 item(s) but got 6 item(s)"]
+  end
+
+  it "should return true if it is at the minimum" do
+    @schema.validate?([1,2,3]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if it is at the maximum" do
+    @schema.validate?([1,2,3,4,5]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if it is within the range" do
+    @schema.validate?([1,2,3,4]).must_equal true
+    @schema.errors.size.must_equal 0
+  end
+
+  it "should return true if the min and max are the same value" do
+    schema = DuckHunt::Schemas::ArraySchema.define :min_size => 3, :max_size => 3 do |s|
+      s.integer
+    end
+    schema.validate?([1,2,3]).must_equal true
+    schema.errors.size.must_equal 0
+  end
+end
+
+describe DuckHunt::Schemas::ArraySchema, "validating `allow nil`" do
+  it "should return false if nil is not allowed and a nil object is given" do
+    schema = DuckHunt::Schemas::ArraySchema.define :allow_nil => false do |s|
+      s.integer
+    end
+    schema.validate?(nil).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["nil object not allowed"]
+  end
+
+  it "should return true if nil is allowed and a nil object is given" do
+    schema = DuckHunt::Schemas::ArraySchema.define :allow_nil => true do |s|
+      s.integer
+    end
+    schema.validate?(nil).must_equal true
+    schema.errors.size.must_equal 0
+  end
+end