@litert/typeguard 1.3.0 → 1.4.0

package/src/test/abstracts.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2022 Angus Fenying <fenying@litert.org>
+ * Copyright 2023 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.
@@ -19,9 +19,9 @@ import * as TypeGuard from '../lib';
 
 export interface ITestItem {
 
-    inputName: string;
+    title: string;
 
-    inputValue: any;
+    value: any;
 
     expect: boolean | 'throw';
 }
@@ -42,60 +42,60 @@ export interface ITestSuite {
     sections: ITestRule[];
 }
 
-export function defaultItemss(
+export function defaultItems(
     items: Record<string, boolean>,
     defaultValue: boolean = false
 ): ITestItem[] {
 
     return [
         {
-            'inputName': 'true',
-            'inputValue': true,
+            'title': 'true',
+            'value': true,
             'expect': items['true'] === undefined ? defaultValue : items['true']
         },
         {
-            'inputName': 'false',
-            'inputValue': false,
+            'title': 'false',
+            'value': false,
             'expect': items['false'] === undefined ? defaultValue : items['false']
         },
         {
-            'inputName': 'undefined',
-            'inputValue': undefined,
+            'title': 'undefined',
+            'value': undefined,
             'expect': items['undefined'] === undefined ? defaultValue : items['undefined']
         },
         {
-            'inputName': 'null',
-            'inputValue': null,
+            'title': 'null',
+            'value': null,
             'expect': items['null'] === undefined ? defaultValue : items['null']
         },
         {
-            'inputName': 'empty array',
-            'inputValue': [],
+            'title': 'empty array',
+            'value': [],
             'expect': items['empty array'] === undefined ? defaultValue : items['empty array']
         },
         {
-            'inputName': 'string \'hello\'',
-            'inputValue': 'hello',
+            'title': 'string \'hello\'',
+            'value': 'hello',
             'expect': items['string \'hello\''] === undefined ? defaultValue : items['string \'hello\'']
         },
         {
-            'inputName': 'empty string',
-            'inputValue': '',
+            'title': 'empty string',
+            'value': '',
             'expect': items['empty string'] === undefined ? defaultValue : items['empty string']
         },
         {
-            'inputName': 'object',
-            'inputValue': {},
+            'title': 'object',
+            'value': {},
             'expect': items['object'] === undefined ? defaultValue : items['object']
         },
         {
-            'inputName': 'number 0',
-            'inputValue': 0,
+            'title': 'number 0',
+            'value': 0,
             'expect': items['number 0'] === undefined ? defaultValue : items['number 0']
         },
         {
-            'inputName': 'number 1',
-            'inputValue': 1,
+            'title': 'number 1',
+            'value': 1,
             'expect': items['number 1'] === undefined ? defaultValue : items['number 1']
         }
     ];
@@ -112,6 +112,20 @@ compiler.addPredefinedType<string>(
     }
 );
 
+compiler.addPredefinedType<string>(
+    'trim_string',
+    function(i, minLen: number = 0, maxLen?: number): i is string {
+        return typeof i === 'string' && i.trim().length >= minLen && i.trim().length <= (maxLen ?? i.length);
+    }
+);
+
+compiler.addPredefinedType<string>(
+    'enum',
+    function(i, ...candidates: any[]): i is string {
+        return candidates.includes(i);
+    }
+);
+
 const compiler2 = TypeGuard.createInlineCompiler();
 
 compiler2.addPredefinedType<string>(
@@ -123,11 +137,25 @@ compiler2.addPredefinedType<string>(
     }
 );
 
+compiler2.addPredefinedType<string>(
+    'trim_string',
+    function(i, minLen: number = 0, maxLen?: number): i is string {
+        return typeof i === 'string' && i.trim().length >= minLen && i.trim().length <= (maxLen ?? i.length);
+    }
+);
+
+compiler2.addPredefinedType<string>(
+    'enum',
+    function(i, ...candidates: any[]): i is string {
+        return candidates.includes(i);
+    }
+);
+
 export function assertItem(input: unknown, expect: boolean | 'throw'): ITestItem {
 
     return {
-        inputName: JSON.stringify(input),
-        inputValue: input,
+        title: JSON.stringify(input),
+        value: input,
         expect
     };
 }
@@ -190,16 +218,16 @@ export function createTestDefinition(suite: ITestSuite) {
                         it(`${
                             item.expect ? 'PASSED' : 'REJECTED'
                         } when input ${
-                            item.inputName
+                            item.title
                         }.`, function() {
 
                             assert.equal(
-                                checkWithTrace(item.inputValue),
+                                checkWithTrace(item.value),
                                 item.expect
                             );
 
                             assert.equal(
-                                checkWithoutTrace(item.inputValue),
+                                checkWithoutTrace(item.value),
                                 item.expect
                             );
                         });