duck-hunt 0.0.3

data/test/schemas/hash_schema_test.rb

@@ -0,0 +1,264 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+
+describe DuckHunt::Schemas::HashSchema, "defining an object through a block" do
+	it "should be able to define a property in the schema" do
+		schema = DuckHunt::Schemas::HashSchema.define do |s|
+			s.test "name"
+		end
+
+		schema.properties.size.must_equal 1
+		schema.properties["name"].wont_be_nil
+		schema.properties["name"].required?.must_equal true
+	end
+
+	it "should be able to set the options of a property in the schema" do
+		schema = DuckHunt::Schemas::HashSchema.define do |s|
+			s.test "name", :required => false
+		end
+
+		schema.properties.size.must_equal 1
+		schema.properties["name"].wont_be_nil
+		schema.properties["name"].required?.must_equal false
+	end
+
+	it "should default the `strict mode` to `true`" do
+    schema = DuckHunt::Schemas::HashSchema.define do |s|
+    end
+
+    schema.strict_mode.must_equal true
+    schema.strict_mode?.must_equal true
+  end
+
+  it "should allow the strict mode to be set to false" do
+    schema = DuckHunt::Schemas::HashSchema.define :strict_mode => false do |s|
+    	s.test "name"
+    end
+    schema.strict_mode.must_equal false
+    schema.strict_mode?.must_equal false
+  end
+end
+
+describe DuckHunt::Schemas::HashSchema, "defining an object without a block" do
+  it "should default the strict mode to true" do
+    schema = DuckHunt::Schemas::HashSchema.new
+    schema.strict_mode.must_equal true
+    schema.strict_mode?.must_equal true
+  end
+
+  it "should allow the strict mode to be set to false" do
+    schema = DuckHunt::Schemas::HashSchema.new(:strict_mode => false)
+    schema.strict_mode.must_equal false
+    schema.strict_mode?.must_equal false
+  end
+end
+
+
+describe DuckHunt::Schemas::HashSchema, "defining properties" do
+	it "should be able to add a new property to the schema, which is required by default" do
+		schema = DuckHunt::Schemas::HashSchema.new
+		schema.test "name"
+		schema.properties.size.must_equal 1
+		schema.properties["name"].wont_be_nil
+		schema.properties["name"].required.must_equal true
+		schema.properties["name"].required?.must_equal true
+	end
+
+	it "should allow a property to be explictly set as required" do
+		schema = DuckHunt::Schemas::HashSchema.new
+		schema.test "name", :required => true
+		schema.test "item", "required" => true
+
+		schema.properties.size.must_equal 2
+
+		schema.properties["name"].wont_be_nil
+		schema.properties["name"].required.must_equal true
+		schema.properties["name"].required?.must_equal true
+		schema.properties["item"].wont_be_nil
+		schema.properties["item"].required.must_equal true
+		schema.properties["item"].required?.must_equal true
+	end
+
+	it "should allow a property to be set as not required" do
+		schema = DuckHunt::Schemas::HashSchema.new
+
+		schema.test "name", :required => false
+		schema.test "item", "required" => false
+
+		schema.properties.size.must_equal 2
+		schema.properties["name"].wont_be_nil
+		schema.properties["name"].required.must_equal false
+		schema.properties["name"].required?.must_equal false
+		schema.properties["item"].wont_be_nil
+		schema.properties["item"].required.must_equal false
+		schema.properties["item"].required?.must_equal false
+	end
+
+	it "should require that properties are named" do
+    schema = DuckHunt::Schemas::HashSchema.new
+    lambda{
+			schema.test
+    }.must_raise(ArgumentError)
+
+    lambda{
+      schema.test ""
+    }.must_raise(ArgumentError)
+  end
+
+
+	it "should prevent a property from being defined multiple times in a schema" do
+		schema = DuckHunt::Schemas::HashSchema.new
+		schema.test "name"
+
+		lambda {
+			schema.test "name"
+		}.must_raise(DuckHunt::PropertyAlreadyDefined)
+	end
+
+	it "should ensure the list of properties cannot be modified" do
+		schema = DuckHunt::Schemas::HashSchema.new
+		schema.test "name"
+		schema.properties.size.must_equal 1
+
+		schema.properties["malicious"] = "muwah ha ha"
+		schema.properties.size.must_equal 1
+
+		lambda{
+			schema.properties = {:malicious => "mwuah ha ha"}
+		}.must_raise(NameError)
+	end
+
+	it "should ensure the list of required properties cannot be modified" do
+		schema = DuckHunt::Schemas::HashSchema.new
+		schema.test "name"
+		lambda{
+			schema.required_properties = {:malicious => "mwuah ha ha"}
+		}.must_raise(NameError)
+	end
+
+  it "should pass a block down to the property being defined" do
+    schema = DuckHunt::Schemas::HashSchema.new
+    schema.test_block_passed "name" do
+      1+1
+    end
+
+    schema.properties["name"].block_passed.must_equal true
+  end
+end
+
+describe DuckHunt::Schemas::HashSchema, "validation (strict mode)" do
+	it "should return false if the object provided is not a hash" do
+		schema = DuckHunt::Schemas::HashSchema.define do |s|
+			s.test "name"
+		end
+
+		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 one of the properties is not valid" do
+		schema = DuckHunt::Schemas::HashSchema.define do |s|
+			s.always_wrong_type "name"
+		end
+
+		schema.validate?({:name => "hello"}).must_equal false
+		schema.errors.size.must_equal 1
+		schema.errors["name"].must_equal ["wrong type"]
+	end
+
+	it "should return false if the object is missing a required property" do
+		schema = DuckHunt::Schemas::HashSchema.define do |s|
+			s.test "name", :required => true
+			s.always_right_type "hello", :required => false
+		end
+
+		schema.validate?({:hello => "hello"}).must_equal false
+		schema.errors.size.must_equal 1
+		schema.errors["name"].must_equal ["required"]
+	end
+
+	it "should return false if the schema has been set to strict mode and the hash provided has extra properties" do
+		schema = DuckHunt::Schemas::HashSchema.define do |s|
+			s.test "name", :required => true
+		end
+
+		schema.validate?({:name => "hello", :hello => "hello"}).must_equal false
+		schema.errors.size.must_equal 1
+		schema.errors["base"].must_equal ["has properties not defined in schema"]
+	end
+
+  it "should not retain the 'has properties not defined in schema' error message when validated twice" do
+    schema = DuckHunt::Schemas::HashSchema.define do |s|
+      s.always_right_type "name", :required => true
+    end
+
+    schema.validate?({:name => "hello", :hello => "hello"}).must_equal false
+    schema.errors.size.must_equal 1
+    schema.errors["base"].must_equal ["has properties not defined in schema"]
+
+    schema.validate?({:name => "hello"}).must_equal true
+    schema.errors.size.must_equal 0
+  end
+end
+
+describe DuckHunt::Schemas::HashSchema, "validation (relaxed mode)" do
+	it "should return false if the object provided is not a hash" do
+		schema = DuckHunt::Schemas::HashSchema.define :strict_mode => false do |s|
+			s.test "name"
+		end
+
+		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 one of the properties is not valid" do
+		schema = DuckHunt::Schemas::HashSchema.define :strict_mode => false do |s|
+			s.always_wrong_type "name"
+		end
+
+		schema.validate?({:name => "hello"}).must_equal false
+		schema.errors.size.must_equal 1
+		schema.errors["name"].must_equal ["wrong type"]
+	end
+
+	it "should return false if the object is missing a required property" do
+		schema = DuckHunt::Schemas::HashSchema.define :strict_mode => false do |s|
+			s.test "name", :required => true
+			s.always_right_type "hello", :required => false
+		end
+
+		schema.validate?({:hello => "hello"}).must_equal false
+		schema.errors.size.must_equal 1
+		schema.errors["name"].must_equal ["required"]
+	end
+
+	it "should return true if the schema has been set to relaxed mode and the hash provided has extra properties" do
+		schema = DuckHunt::Schemas::HashSchema.define :strict_mode => false do |s|
+			s.always_right_type "name", :required => true
+		end
+
+		schema.validate?({:name => "hello", :hello => "hello"}).must_equal true
+		schema.errors.size.must_equal 0
+	end
+end
+
+describe DuckHunt::Schemas::HashSchema, "validating `allow nil`" do
+  it "should return false if nil is not allowed and a nil object is given" do
+    schema = DuckHunt::Schemas::HashSchema.define :allow_nil => false do |s|
+      s.test "name"
+    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::HashSchema.define :allow_nil => true do |s|
+      s.test "name"
+    end
+    schema.validate?(nil).must_equal true
+    schema.errors.size.must_equal 0
+  end
+end

data/test/schemas/property_lookup_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class PropertyLookupTestClass
+  include DuckHunt::Schemas::PropertyLookup
+end
+
+class PropertyLookupBlockPassTestClass
+  include DuckHunt::Schemas::PropertyLookup
+  attr_reader :block_passed
+  def add_property(property_constant, *args, &block)
+    @block_passed = true if block_given?
+  end
+end
+
+describe DuckHunt::Schemas::PropertyLookup, "Adding a property to the schema" do
+  it "should raise a `NotImplementedError` if the property definition exists (classes using this module must implement `add_property`" do
+    schema = PropertyLookupTestClass.new
+    lambda {
+      schema.test
+    }.must_raise(NotImplementedError)
+  end
+
+  it "should raise NoMethodError if the property definition does not exist (it was not found)" do
+    schema = PropertyLookupTestClass.new
+    lambda {
+      schema.herp
+    }.must_raise(NoMethodError)
+  end
+
+  it "should pass the provided block down for property initializers to use" do
+    schema = PropertyLookupBlockPassTestClass.new
+    schema.test { 1+1 }
+    schema.block_passed.must_equal true
+  end
+
+  it "should not break if a block is not provided" do
+    schema = PropertyLookupBlockPassTestClass.new
+    schema.test
+    schema.block_passed.must_be_nil
+  end
+end

data/test/schemas/schema_definition_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class SchemaDefinitionTestClass
+  include DuckHunt::Schemas::SchemaDefinition
+
+  attr_accessor :other_value
+
+  def initialize(options=nil)
+    self.other_value = "hello"
+    self.other_value = options unless options.nil?
+  end
+
+  def setter!
+    @value = 1
+  end
+
+  def getter
+    @value
+  end
+end
+
+describe DuckHunt::Schemas::SchemaDefinition, "defining an object through a block" do
+  it "should accept a block through the `define` method and use it create a new instance of the class and call instance methods" do
+    schema = SchemaDefinitionTestClass.define do |s|
+      s.setter!
+    end
+
+    schema.must_be_instance_of SchemaDefinitionTestClass
+    schema.getter.must_equal 1
+  end
+
+  it "should still call the `initialize` method defined in the class when `define` is used" do
+    schema = SchemaDefinitionTestClass.define do |s|
+      s.setter!
+    end
+
+    schema.must_be_instance_of SchemaDefinitionTestClass
+    schema.getter.must_equal 1
+    schema.other_value.must_equal "hello"
+  end
+
+  it "should pass initialization parameters to the class when `define` is used" do
+    schema = SchemaDefinitionTestClass.define "neato!" do |s|
+      s.setter!
+    end
+
+    schema.must_be_instance_of SchemaDefinitionTestClass
+    schema.getter.must_equal 1
+    schema.other_value.must_equal "neato!"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+# add our ./lib path to the require paths
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+# add our test path to the require paths (used when loading test helpers)
+$: << File.expand_path(File.dirname(__FILE__))
+
+# load our gems installed via Bundler
+require 'rubygems'
+require 'bundler/setup'
+
+# try to load common debugging gems
+["ruby-debug", "debugger"].each{|debugging_library|
+	begin
+  	require debugging_library
+	rescue LoadError
+  	# no big deal; it's only useful in development
+	end
+}
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/pride'
+require 'mocha/setup'
+require 'set'
+require 'bigdecimal'
+require 'duck-hunt'
+
+#require some basic test classes (useful for testing modules independently)
+require 'test_helper/test_classes'

data/test/test_helper/test_classes.rb

@@ -0,0 +1,74 @@
+class DuckHunt::Properties::Test < DuckHunt::Properties::Property
+end
+
+class DuckHunt::Properties::TestBlockPassed < DuckHunt::Properties::Property
+  attr_reader :block_passed
+  def initialize(options={}, &block)
+    @block_passed = true if block_given?
+  end
+end
+
+class DuckHunt::Properties::AlwaysRightType < DuckHunt::Properties::Property
+  def matches_type?(value)
+    return true
+  end
+end
+
+class DuckHunt::Properties::AlwaysWrongType < DuckHunt::Properties::Property
+  def matches_type?(value)
+    return false
+  end
+end
+
+class DuckHunt::Validators::Test < DuckHunt::Validators::Validator
+end
+
+class DuckHunt::Validators::AlwaysWrong < DuckHunt::Validators::Validator
+  def valid?(value)
+    return false
+  end
+
+  def error_message
+    "Always Wrong"
+  end
+end
+
+class DuckHunt::Validators::WrongAgain < DuckHunt::Validators::Validator
+  def valid?(value)
+    return false
+  end
+
+  def error_message
+    "Wrong Again"
+  end
+end
+
+class DuckHunt::Validators::AlwaysRight < DuckHunt::Validators::Validator
+  def valid?(value)
+    return true
+  end
+
+  def error_message
+    "How did this happen?"
+  end
+end
+
+class DuckHunt::Validators::RightAgain < DuckHunt::Validators::Validator
+  def valid?(value)
+    return true
+  end
+
+  def error_message
+    "Wha?"
+  end
+end
+
+class DuckHunt::Validators::AlwaysRaiseException < DuckHunt::Validators::Validator
+  def valid?(value)
+    raise Exception, "Bad!"
+  end
+
+  def error_message
+    "Bad!"
+  end
+end