@litert/typeguard 1.0.1 → 1.3.0-dev.0

package/src/test/08-map-and-dict.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,127 +20,127 @@ import {
     ITestSuite,
     assertItem,
     addRule
-} from "./abstracts";
+} from './abstracts';
 
 const testItems: ITestSuite = {
 
-    name: "Mappings & Dicts",
+    name: 'Mappings & Dicts',
     sections: [
 
         {
-            "name": JSON.stringify(["$.map", "string", "uint32"]),
-            "rule": ["$.map", "string", "uint32"],
-            "items": [
+            'name': JSON.stringify(['$.map', 'string', 'uint32']),
+            'rule': ['$.map', 'string', 'uint32'],
+            'items': [
                 {
-                    inputName: "all string object",
-                    inputValue: {"a": "123312312", "b": "ccc" },
+                    inputName: 'all string object',
+                    inputValue: { 'a': '123312312', 'b': 'ccc' },
                     expect: true
                 },
                 {
-                    inputName: "all uint32 object",
-                    inputValue: {"a": 123312312, "b": 0xCCC },
+                    inputName: 'all uint32 object',
+                    inputValue: { 'a': 123312312, 'b': 0xCCC },
                     expect: true
                 },
                 {
-                    inputName: "all uint32 & string object",
-                    inputValue: {"a": 123312312, "b": 0xCCC },
+                    inputName: 'all uint32 & string object',
+                    inputValue: { 'a': 123312312, 'b': 0xCCC },
                     expect: true
                 },
                 {
-                    inputName: "all uint32 & boolean object",
-                    inputValue: {"a": 123312312, "b": false },
+                    inputName: 'all uint32 & boolean object',
+                    inputValue: { 'a': 123312312, 'b': false },
                     expect: false
                 },
                 ...defaultItemss({
-                    "object": true
+                    'object': true
                 })
             ]
         },
         {
-            "name": JSON.stringify({
-                "a": "string",
-                "$.map": "number"
+            'name': JSON.stringify({
+                'a': 'string',
+                '$.map': 'number'
             }),
-            "rule": {
-                "a": "string",
-                "$.map": "number"
+            'rule': {
+                'a': 'string',
+                '$.map': 'number'
             },
-            "items": [
+            'items': [
                 assertItem(
-                    {"a": "123312312", "b": 123.3, c: 1232 },
+                    { 'a': '123312312', 'b': 123.3, c: 1232 },
                     true
                 ),
                 assertItem(
-                    {"a": "123312312", "b": "ccc" },
+                    { 'a': '123312312', 'b': 'ccc' },
                     false
                 ),
                 assertItem(
-                    {"a": 123312312, "b": 123.3 },
+                    { 'a': 123312312, 'b': 123.3 },
                     false
                 ),
             ]
         },
         {
-            "name": JSON.stringify({
-                "a": "string",
-                "b->{}": "number"
+            'name': JSON.stringify({
+                'a': 'string',
+                'b->{}': 'number'
             }),
-            "rule": {
-                "a": "string",
-                "b->{}": "number"
+            'rule': {
+                'a': 'string',
+                'b->{}': 'number'
             },
-            "items": [
+            'items': [
                 assertItem(
-                    {"a": "123312312", "b": "ccc" },
+                    { 'a': '123312312', 'b': 'ccc' },
                     false
                 ),
                 assertItem(
-                    {"a": 123312312, "b": 123.3 },
+                    { 'a': 123312312, 'b': 123.3 },
                     false
                 ),
                 assertItem(
-                    {"a": "123312312", "b": {d: 123.3, c: 1232} },
+                    { 'a': '123312312', 'b': { d: 123.3, c: 1232 } },
                     true
                 ),
                 assertItem(
-                    {"a": "123312312", "b": { d: 123.3, c: "1232" } },
+                    { 'a': '123312312', 'b': { d: 123.3, c: '1232' } },
                     false
                 ),
             ]
         },
-        addRule(["$.dict", ["a", "b"], "string"], [
+        addRule(['$.dict', ['a', 'b'], 'string'], [
             assertItem(
-                {"a": "123312312", "b": "ccc" },
+                { 'a': '123312312', 'b': 'ccc' },
                 true
             ),
             assertItem(
-                {"a": "123312312", "b": "ccc", "c": 123 },
+                { 'a': '123312312', 'b': 'ccc', 'c': 123 },
                 true
             ),
             assertItem(
-                {"a": "123312312" },
+                { 'a': '123312312' },
                 false
             ),
             assertItem(
-                {"a": "123312312", "c": "ddd" },
+                { 'a': '123312312', 'c': 'ddd' },
                 false
             ),
             assertItem(
-                {"a": "123312312", "b": 123.3 },
+                { 'a': '123312312', 'b': 123.3 },
                 false
             )
         ]),
-        addRule(["$.strict", "$.dict", ["a", "b"], "string"], [
+        addRule(['$.strict', '$.dict', ['a', 'b'], 'string'], [
             assertItem(
-                {"a": "123312312", "b": "ccc" },
+                { 'a': '123312312', 'b': 'ccc' },
                 true
             ),
             assertItem(
-                {"a": "123312312", "b": "ccc", "c": 123 },
+                { 'a': '123312312', 'b': 'ccc', 'c': 123 },
                 false
             ),
             assertItem(
-                {"a": "123312312" },
+                { 'a': '123312312' },
                 false
             ),
         ])

package/src/test/09-exceptions.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,29 +17,50 @@
 import {
     createTestDefinition,
     ITestSuite
-} from "./abstracts";
+} from './abstracts';
 
 const testItems: ITestSuite = {
 
-    name: "When optional with any",
+    name: 'When optional with any',
     sections: [
 
         {
-            "name": JSON.stringify({ "test?": "any" }),
-            "rule": { "test?": "any" },
-            "items": [
+            'name': JSON.stringify({ 'test?': 'any' }),
+            'rule': { 'test?': 'any' },
+            'items': [
                 {
-                    inputName: "When test === 'ffff'",
-                    inputValue: {"test": "ffff"},
+                    inputName: 'When test === \'ffff\'',
+                    inputValue: { 'test': 'ffff' },
                     expect: true
                 },
                 {
-                    inputName: "When test is omitted",
+                    inputName: 'When test is omitted',
                     inputValue: {},
                     expect: true
                 }
             ]
         },
+        {
+            'name': JSON.stringify({ 'test': 'int8' }),
+            'rule': { 'test': 'int8' },
+            'items': [
+                {
+                    inputName: 'When test === 123',
+                    inputValue: { 'test': 123 },
+                    expect: true
+                },
+                {
+                    inputName: 'When test === 1234',
+                    inputValue: { 'test': 1234 },
+                    expect: false
+                },
+                {
+                    inputName: 'When test is omitted',
+                    inputValue: {},
+                    expect: false
+                }
+            ]
+        },
     ]
 };
 

package/src/test/abstracts.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import * as assert from "assert";
-import * as TypeGuard from "../lib";
+import * as assert from 'assert';
+import * as TypeGuard from '../lib';
 
 export interface ITestItem {
 
@@ -23,7 +23,7 @@ export interface ITestItem {
 
     inputValue: any;
 
-    expect: boolean | "throw";
+    expect: boolean | 'throw';
 }
 
 export interface ITestRule {
@@ -49,61 +49,81 @@ export function defaultItemss(
 
     return [
         {
-            "inputName": "true",
-            "inputValue": true,
-            "expect": items["true"] === undefined ? defaultValue : items["true"]
+            'inputName': 'true',
+            'inputValue': true,
+            'expect': items['true'] === undefined ? defaultValue : items['true']
         },
         {
-            "inputName": "false",
-            "inputValue": false,
-            "expect": items["false"] === undefined ? defaultValue : items["false"]
+            'inputName': 'false',
+            'inputValue': false,
+            'expect': items['false'] === undefined ? defaultValue : items['false']
         },
         {
-            "inputName": "undefined",
-            "inputValue": undefined,
-            "expect": items["undefined"] === undefined ? defaultValue : items["undefined"]
+            'inputName': 'undefined',
+            'inputValue': undefined,
+            'expect': items['undefined'] === undefined ? defaultValue : items['undefined']
         },
         {
-            "inputName": "null",
-            "inputValue": null,
-            "expect": items["null"] === undefined ? defaultValue : items["null"]
+            'inputName': 'null',
+            'inputValue': null,
+            'expect': items['null'] === undefined ? defaultValue : items['null']
         },
         {
-            "inputName": "empty array",
-            "inputValue": [],
-            "expect": items["empty array"] === undefined ? defaultValue : items["empty array"]
+            'inputName': 'empty array',
+            'inputValue': [],
+            'expect': items['empty array'] === undefined ? defaultValue : items['empty array']
         },
         {
-            "inputName": "string 'hello'",
-            "inputValue": "hello",
-            "expect": items["string 'hello'"] === undefined ? defaultValue : items["string 'hello'"]
+            'inputName': 'string \'hello\'',
+            'inputValue': 'hello',
+            'expect': items['string \'hello\''] === undefined ? defaultValue : items['string \'hello\'']
         },
         {
-            "inputName": "empty string",
-            "inputValue": "",
-            "expect": items["empty string"] === undefined ? defaultValue : items["empty string"]
+            'inputName': 'empty string',
+            'inputValue': '',
+            'expect': items['empty string'] === undefined ? defaultValue : items['empty string']
         },
         {
-            "inputName": "object",
-            "inputValue": {},
-            "expect": items["object"] === undefined ? defaultValue : items["object"]
+            'inputName': 'object',
+            'inputValue': {},
+            'expect': items['object'] === undefined ? defaultValue : items['object']
         },
         {
-            "inputName": "number 0",
-            "inputValue": 0,
-            "expect": items["number 0"] === undefined ? defaultValue : items["number 0"]
+            'inputName': 'number 0',
+            'inputValue': 0,
+            'expect': items['number 0'] === undefined ? defaultValue : items['number 0']
         },
         {
-            "inputName": "number 1",
-            "inputValue": 1,
-            "expect": items["number 1"] === undefined ? defaultValue : items["number 1"]
+            'inputName': 'number 1',
+            'inputValue': 1,
+            'expect': items['number 1'] === undefined ? defaultValue : items['number 1']
         }
     ];
 }
 
 const compiler = TypeGuard.createInlineCompiler();
 
-export function assertItem(input: any, expect: boolean | "throw"): ITestItem {
+compiler.addPredefinedType<string>(
+    'ipv4_address',
+    function(i): i is string {
+        return  typeof i === 'string'
+            && /^[0-9]{1,3}(\.[0-9]{1,3}){3}$/.test(i)
+            && i.split('.').map(x => parseInt(x, 10)).every(x => x >= 0 && x <= 255);
+    }
+);
+
+const compiler2 = TypeGuard.createInlineCompiler();
+
+compiler2.addPredefinedType<string>(
+    'ipv4_address',
+    function(i): i is string {
+        return  typeof i === 'string'
+            && /^[0-9]{1,3}(\.[0-9]{1,3}){3}$/.test(i)
+            && i.split('.').map(x => parseInt(x, 10)).every(x => x >= 0 && x <= 255);
+    }
+);
+
+export function assertItem(input: unknown, expect: boolean | 'throw'): ITestItem {
 
     return {
         inputName: JSON.stringify(input),
@@ -112,7 +132,7 @@ export function assertItem(input: any, expect: boolean | "throw"): ITestItem {
     };
 }
 
-export function addRule(rule: any, items: ITestItem[]): ITestRule {
+export function addRule(rule: unknown, items: ITestItem[]): ITestRule {
 
     return {
         name: JSON.stringify(rule),
@@ -127,41 +147,59 @@ export function createTestDefinition(suite: ITestSuite) {
 
         describe(suite.name, function() {
 
-            for (let section of suite.sections) {
+            for (const section of suite.sections) {
 
                 describe(section.name, function() {
 
                     if (
                         section.items.length === 1 &&
-                        section.items[0].expect === "throw"
+                        section.items[0].expect === 'throw'
                     ) {
 
-                        it(`Throws exception.`, function() {
+                        it('Throws exception.', function() {
 
                             assert.throws(() => {
 
                                 compiler.compile<any>({
-                                    "rule": section.rule
+                                    'rule': section.rule,
+                                    traceErrors: true,
+                                });
+                            });
+
+                            assert.throws(() => {
+
+                                compiler2.compile<any>({
+                                    'rule': section.rule,
                                 });
                             });
                         });
                         return;
                     }
 
-                    const check = compiler.compile<any>({
-                        "rule": section.rule
+                    const checkWithTrace = compiler.compile<any>({
+                        'rule': section.rule,
+                        traceErrors: true,
+                    });
+
+                    const checkWithoutTrace = compiler2.compile<any>({
+                        'rule': section.rule,
                     });
 
-                    for (let item of section.items.sort((a, b) => a.expect === b.expect ? 0 : (a.expect ? -1 : 1))) {
+                    for (const item of section.items.sort((a, b) => a.expect === b.expect ? 0 : (a.expect ? -1 : 1))) {
 
                         it(`${
-                            item.expect ? "PASSED" : "REJECTED"
+                            item.expect ? 'PASSED' : 'REJECTED'
                         } when input ${
                             item.inputName
                         }.`, function() {
 
                             assert.equal(
-                                check(item.inputValue),
+                                checkWithTrace(item.inputValue),
+                                item.expect
+                            );
+
+                            assert.equal(
+                                checkWithoutTrace(item.inputValue),
                                 item.expect
                             );
                         });