Add unit tests for Runtime and fix validateObject(#59)

Author: kungfooman

package.json

@@ -9,7 +9,7 @@
     "build:atBabelCore": "rollup -c --environment target:atBabelCore",
     "build:dts": "tsc src-transpiler/index.mjs --outDir types/transpiler --allowJs --declaration --emitDeclarationOnly --target esnext",
     "build:types": "npm run build:dts && rollup -c --environment target:types",
-    "test": "npm run test:update && node test.mjs",
+    "test": "npm run test:update && node test.mjs && node test_runtime.mjs",
     "test:update": "node gen_tests.mjs > test/typechecking.json",
     "lint": "eslint --ext .js,.mjs,.cjs src-transpiler src-runtime",
     "docs": "echo todo docs using jsdoc"

src-runtime/assertType.mjs

@@ -8,7 +8,7 @@ import {validateType        } from "./validateType.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 export function assertType(value, expect, loc, name, critical = true) {
   if (!expect) {

src-runtime/validateArray.mjs

@@ -6,7 +6,7 @@ import {typecheckEvery} from "./typecheckEvery.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateArray(value, expect, loc, name, critical) {
   if (value && value instanceof Array) {

src-runtime/validateMap.mjs

@@ -7,7 +7,7 @@ import {typecheckWarn} from "./typecheckWarn.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateMap(value, expect, loc, name, critical) {
   const {key, val} = expect;

src-runtime/validateObject.mjs

@@ -1,16 +1,31 @@
 import {assertType      } from "./assertType.mjs";
 import {typecheckOptions} from "./typecheckOptions.mjs";
 import {typecheckWarn   } from "./typecheckWarn.mjs";
+/**
+ * Did you ever heard of Anakandavada, the doctrine of manifoldness of reality?
+ * 1) Check: typeof value === 'object'
+ * 2) Check: value instanceof Object
+ * 3) Check (1) *and* (2)
+ * 4) neither
+ * You may ponder to either use (1) or (2), but only (3) is right, because:
+ * 1) Fails for functions, every function is also an object: Math.sqrt.test = "Hai"
+ * 2) Fails for prototype-less objects: Object.create(null) instanceof Object === false.
+ * @param {*} value - The actual value that we need to validate.
+ * @returns {boolean} Boolean indicating if value is an object.
+ */
+function isObject(value) {
+  return value instanceof Object || typeof value === 'object';
+}
 /**
  * @param {*} value - The actual value that we need to validate.
  * @param {*} properties - The properties.
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateObject(value, properties, loc, name, critical) {
-  if (!(value instanceof Object)) {
+  if (!isObject(value)) {
     return false;
   }
   if (properties && Object.keys(properties).length) {
@@ -38,6 +53,6 @@ function validateObject(value, properties, loc, name, critical) {
       );
     });
   }
-  return value instanceof Object;
+  return true;
 }
 export {validateObject};

src-runtime/validateRecord.mjs

@@ -6,7 +6,7 @@ import {typecheckWarn} from "./typecheckWarn.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateRecord(value, expect, loc, name, critical) {
   const {key, val} = expect;

src-runtime/validateSet.mjs

@@ -6,7 +6,7 @@ import {typecheckWarn} from "./typecheckWarn.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateSet(value, expect, loc, name, critical) {
   if (!(value instanceof Set)) {

src-runtime/validateTuple.mjs

@@ -5,7 +5,7 @@ import {assertType} from "./assertType.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateTuple(value, expect, loc, name, critical) {
   if (!value) {

src-runtime/validateType.mjs

@@ -33,7 +33,7 @@ const props16   = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument.
  * @param {boolean} critical - Only false for unions.
- * @returns {boolean} - Returns wether `value` is in the shape of `expect`.
+ * @returns {boolean} Returns wether `value` is in the shape of `expect`.
  */
 function validateType(value, expect, loc, name, critical = true) {
   if (typeof expect === 'string') {

src-runtime/validateTypedef.mjs

@@ -6,7 +6,7 @@ import {validateType} from "./validateType.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateTypedef(value, expect, loc, name, critical) {
   if (expect.optional && value === undefined) {

src-runtime/validateUnion.mjs

@@ -5,7 +5,7 @@ import {assertType} from "./assertType.mjs";
  * @param {string} loc - String like `BoundingBox#compute`
  * @param {string} name - Name of the argument
  * @param {boolean} critical - Only `false` for unions.
- * @returns {boolean} - Boolean indicating if a type is correct.
+ * @returns {boolean} Boolean indicating if a type is correct.
  */
 function validateUnion(value, expect, loc, name, critical) {
   return expect.members.some(member => assertType(

test/typechecking.json

@@ -71,6 +71,10 @@
     "input": "./test/typechecking/typedef-new-input.mjs",
     "output": "./test/typechecking/typedef-new-output.mjs"
   },
+  {
+    "input": "./test/typechecking/typedef-overwrite-input.mjs",
+    "output": "./test/typechecking/typedef-overwrite-output.mjs"
+  },
   {
     "input": "./test/typechecking/typedef-promise-input.mjs",
     "output": "./test/typechecking/typedef-promise-output.mjs"

test_runtime.mjs

@@ -0,0 +1,22 @@
+import {validateType} from './src-runtime/validateType.mjs';
+// We expect all functions to return true.
+const tests = [
+  () => validateType({},                  {type: 'object', optional: false}, 'loc', 'name', true),
+  // There is no type distinction between a "normal" and "prototype-less" object
+  () => validateType(Object.create(null), {type: 'object', optional: false}, 'loc', 'name', true),
+  // Every function is also an object
+  () => validateType(Math.sqrt,           {type: 'object', optional: false}, 'loc', 'name', true),
+  () => validateType(new Date(),          {type: 'object', optional: false}, 'loc', 'name', true),
+  () => validateType(1,                   {type: 'object', optional: false}, 'loc', 'name', true) === false,
+  () => validateType('nope',              {type: 'object', optional: false}, 'loc', 'name', true) === false,
+  () => validateType(Symbol('nope'),      {type: 'object', optional: false}, 'loc', 'name', true) === false,
+];
+let errors = 0;
+for (const test of tests) {
+  const ret = test();
+  if (!ret) {
+    console.error("Test failed: " + test);
+    errors++;
+  }
+}
+process.exit(errors); // 0 means success