fix: object property validation and more tests

Author: jedwards1211

src/errorMessages.ts

@@ -26,10 +26,10 @@ const errorMessages = {
   ERR_EXPECT_THIS: 'must be exactly this',
   ERR_EXPECT_VOID: 'must be undefined',
   ERR_INVALID_DATE: 'must be a valid date',
-  ERR_MISSING_PROPERTY: 'does not exist on object',
+  ERR_MISSING_PROPERTY: 'must have property: $0',
   ERR_NO_INDEXER: 'is not one of the permitted indexer types',
   ERR_NO_UNION: 'must be one of: $0',
-  ERR_UNKNOWN_KEY: 'should not contain the key: "$0"',
+  ERR_UNKNOWN_KEY: 'should not contain the key: $0',
 }
 
 export type ErrorKey = keyof typeof errorMessages

src/errorReporting/makeTypeError.ts

@@ -16,7 +16,7 @@ export default function makeTypeError<T>(
   const { prefix, input, errors } = validation
   const collected = []
   for (const [path, message, expectedType] of errors) {
-    const expected = expectedType ? expectedType.toString() : '*'
+    const expected = expectedType ? expectedType.toString() : 'any'
     const actual = resolvePath(input, path)
     const actualType = typeOf(actual)
 

src/errorReporting/typeOf.ts

@@ -1,4 +1,4 @@
-function keyToString(key: string | number | symbol): string {
+export function keyToString(key: string | number | symbol): string {
   switch (typeof key) {
     case 'symbol':
       return `[${String(key)}]`

src/null.spec.ts

@@ -0,0 +1,27 @@
+import * as t from './'
+import { expect } from 'chai'
+import dedent from 'dedent-js'
+import typeOf from './errorReporting/typeOf'
+
+describe(`t.null`, function() {
+  it(`accepts null`, function() {
+    t.null().assert(null)
+    expect(t.null().accepts(null)).to.be.true
+  })
+  it(`rejects everything else`, function() {
+    for (const value of [true, 'foo', undefined, 2, [], {}]) {
+      expect(t.null().accepts(value)).to.be.false
+      expect(() => t.null().assert(value)).to.throw(
+        t.RuntimeTypeError,
+        dedent`
+        Value must be null
+
+        Expected: null
+
+        Actual Value: ${JSON.stringify(value)}
+
+        Actual Type: ${typeOf(value)}`
+      )
+    }
+  })
+})

src/object.spec.ts

@@ -0,0 +1,66 @@
+import * as t from './'
+import { expect } from 'chai'
+import dedent from 'dedent-js'
+import typeOf from './errorReporting/typeOf'
+
+describe(`t.object`, function() {
+  const Person = t.object<{ name: any; age?: any }>()({
+    name: t.string(),
+    age: t.optionalNullOr(t.number()),
+  })
+  it(`accepts matching object`, function() {
+    for (const value of [
+      { name: 'Jimbo' },
+      { name: 'Jimbo', age: null },
+      { name: 'Jimbo', age: 20 },
+    ]) {
+      expect(Person.accepts(value)).to.be.true
+      Person.assert(value)
+    }
+  })
+  it(`rejects missing properties`, function() {
+    expect(Person.accepts({ age: 20 })).to.be.false
+    expect(() => Person.assert({ age: 20 })).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+        Value must have property: name
+
+        Expected: ${Person.toString()}
+
+        Actual Value: ${JSON.stringify({ age: 20 }, null, 2)}
+
+        Actual Type: ${typeOf({ age: 20 })}`
+    )
+  })
+  it(`rejects extraneous properties`, function() {
+    const value = { name: 'Jimbo', powerLevel: 9001 }
+    expect(Person.accepts(value)).to.be.false
+    expect(() => Person.assert(value)).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+        Value should not contain the key: powerLevel
+
+        Expected: ${Person.toString()}
+
+        Actual Value: ${JSON.stringify(value, null, 2)}
+
+        Actual Type: ${typeOf(value)}`
+    )
+  })
+  it(`rejects everything else`, function() {
+    for (const value of [true, 'foo', undefined, 2, []]) {
+      expect(Person.accepts(value)).to.be.false
+      expect(() => Person.assert(value)).to.throw(
+        t.RuntimeTypeError,
+        dedent`
+        Value must be an object
+
+        Expected: ${Person.toString()}
+
+        Actual Value: ${JSON.stringify(value)}
+
+        Actual Type: ${typeOf(value)}`
+      )
+    }
+  })
+})

src/ref.spec.ts

@@ -58,7 +58,7 @@ describe(`t.ref`, function() {
     ).to.throw(
       t.RuntimeTypeError,
       dedent`
-        node.left.right should not contain the key: "bar"
+        node.left.right should not contain the key: bar
 
         Expected: {
           value: any;

src/types/ObjectType.ts

@@ -18,6 +18,7 @@ import {
   startToStringCycle,
   endToStringCycle,
 } from '../cyclic'
+import { keyToString } from '../errorReporting/typeOf'
 
 export default class ObjectType<T extends {}> extends Type<T> {
   typeName = 'ObjectType'
@@ -34,6 +35,7 @@ export default class ObjectType<T extends {}> extends Type<T> {
     this.properties = properties
     this.indexers = indexers
     this.exact = exact
+    properties.forEach(prop => (prop.__objectType = this))
   }
 
   *errors(
@@ -46,7 +48,7 @@ export default class ObjectType<T extends {}> extends Type<T> {
       return
     }
 
-    if (typeof input !== 'object') {
+    if (typeof input !== 'object' || Array.isArray(input)) {
       yield [path, getErrorMessage('ERR_EXPECT_OBJECT'), this]
       return
     }
@@ -75,7 +77,7 @@ export default class ObjectType<T extends {}> extends Type<T> {
     if (input === null) {
       return false
     }
-    if (typeof input !== 'object') {
+    if (typeof input !== 'object' || Array.isArray(input)) {
       return false
     }
     if (inValidationCycle(this, input)) {
@@ -226,7 +228,7 @@ function* collectErrorsExact(
   for (const key in input) {
     // eslint-disable-line guard-for-in
     if (!properties.some(property => property.key === key)) {
-      yield [path, getErrorMessage('ERR_UNKNOWN_KEY', key), type]
+      yield [path, getErrorMessage('ERR_UNKNOWN_KEY', keyToString(key)), type]
     }
   }
 }

src/types/ObjectTypeProperty.ts

@@ -10,6 +10,7 @@ import {
 
 import Validation, { ErrorTuple, IdentifierPath } from '../Validation'
 import getErrorMessage from '../getErrorMessage'
+import { keyToString } from '../errorReporting/typeOf'
 
 export default class ObjectTypeProperty<
   K extends string | number | symbol,
@@ -20,6 +21,7 @@ export default class ObjectTypeProperty<
   readonly value: Type<V>
   readonly optional: boolean
   readonly constraints: TypeConstraint<V>[] = []
+  __objectType: Type<any> = null as any
 
   constructor(key: K, value: Type<V>, optional: boolean) {
     super()
@@ -50,7 +52,11 @@ export default class ObjectTypeProperty<
     // @flowIgnore
     const { optional, key, value } = this
     if (!optional && !this.existsOn(input)) {
-      yield [path, getErrorMessage('ERR_MISSING_PROPERTY'), input]
+      yield [
+        path,
+        getErrorMessage('ERR_MISSING_PROPERTY', keyToString(key)),
+        this.__objectType,
+      ]
       return
     }
     const target = input[key]

src/undefined.spec.ts

@@ -0,0 +1,27 @@
+import * as t from './'
+import { expect } from 'chai'
+import dedent from 'dedent-js'
+import typeOf from './errorReporting/typeOf'
+
+describe(`t.undefined`, function() {
+  it(`accepts undefined`, function() {
+    t.undefined().assert(undefined)
+    expect(t.undefined().accepts(undefined)).to.be.true
+  })
+  it(`rejects everything else`, function() {
+    for (const value of [true, 'foo', null, 2, [], {}]) {
+      expect(t.undefined().accepts(value)).to.be.false
+      expect(() => t.undefined().assert(value)).to.throw(
+        t.RuntimeTypeError,
+        dedent`
+        Value must be undefined
+
+        Expected: undefined
+
+        Actual Value: ${JSON.stringify(value)}
+
+        Actual Type: ${typeOf(value)}`
+      )
+    }
+  })
+})