describe "internal/Validator", ->

	Validator = require "./../Validator"

	describe "validate()", ->
	
		it "sets default values for undefined keys", ->
			target = {}
			defaults =
				foo: true
			Validator.validate { target, defaults }
			expect(target.foo).toBe defaults.foo

		it "doesnt set default values for defined keys", ->
			target =
				foo: false
			defaults =
				foo: true
			Validator.validate { target, defaults }
			expect(target.foo).toBe false

		it "creates an object for default nested values if an object does not already exist", ->
			target = {}
			defaults =
				foo:
					bar: true
			Validator.validate { target, defaults }
			expect(target.nest.foo).toBe defaults.nest.foo

		it "fills in defaults of nested values", ->
			target =
				nest: {}
			defaults =
				nest:
					foo: true
			Validator.validate { target, defaults }
			expect(target.nest.foo).toBe defaults.nest.foo

		it "doesnt overwrite pre-existing object properties when filling in default nested values", ->
			target =
				nest:
					bar: true
			defaults =
				nest:
					foo: true
			Validator.validate { target, defaults }
			expect(target.nest.bar).toBe true

		it "throws an error if all properties are not their expected types", ->
			target =
				foo: true
				bar: []
			types =
				foo: Boolean
				bar: Boolean
			try Validator.validate { target, types }
			catch error then expect(error?).toBe true

		# it "supports custom validation", ->
		# 	target =
		# 		foo: 1000
		# 	specs =
		# 		foo: (value) -> Math.min value, 100 # max limit of 100 
		# 	Type.validate target, specs
		# 	expect(target.foo).toBe 100

	# it "throws an error if a required type isn't fulfilled", ->
	# 	target = {}
	# 	types =
	# 		foo: Required Boolean

	# 	Validator.validate { target, types }