@litert/typeguard 1.3.0 → 1.4.1

package/src/test/06-structure.ts

@@ -1,277 +0,0 @@
-/**
- * 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.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { createTestDefinition, defaultItemss, ITestSuite } from './abstracts';
-
-const testItems: ITestSuite = {
-
-    name: 'Structure',
-    sections: [
-
-        {
-            'name': 'Empty object',
-            'rule': {},
-            'items': [
-                {
-                    inputName: 'Empty object',
-                    inputValue: {},
-                    expect: true
-                },
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: true
-                },
-                {
-                    inputName: '[int, string]',
-                    inputValue: [123, 'fff'],
-                    expect: false
-                },
-                ...defaultItemss({
-                    'object': true
-                })
-            ]
-        },
-        {
-            'name': '1 property object',
-            'rule': { 'a': 'uint32' },
-            'items': [
-                {
-                    inputName: 'Empty object',
-                    inputValue: {},
-                    expect: false
-                },
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: true
-                },
-                {
-                    inputName: '[int, string]',
-                    inputValue: [123, 'fff'],
-                    expect: false
-                },
-                ...defaultItemss({
-                    'object': false
-                })
-            ]
-        },
-        {
-            'name': '1 optional property object',
-            'rule': { 'a?': 'uint32' },
-            'items': [
-                {
-                    inputName: 'Empty object',
-                    inputValue: {},
-                    expect: true
-                },
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: true
-                },
-                {
-                    inputName: 'Object with one mismatch-type property',
-                    inputValue: { 'a': '123' },
-                    expect: false
-                },
-                {
-                    inputName: '[int, string]',
-                    inputValue: [123, 'fff'],
-                    expect: false
-                },
-                ...defaultItemss({
-                    'object': true
-                })
-            ]
-        },
-        {
-            'name': 'Nested object',
-            'rule': { 'a?': 'uint32', 'b': { 'c': 'string' } },
-            'items': [
-                {
-                    inputName: 'Empty object',
-                    inputValue: {},
-                    expect: false
-                },
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with mismatch-typed nest property',
-                    inputValue: { 'a': 123, 'b': { 'c': 1232131 } },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with one mismatch-typed property',
-                    inputValue: { 'a': '123', 'b': { 'c': 'ffff' } },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with all corrected',
-                    inputValue: { 'a': 123, 'b': { 'c': 'ffff' } },
-                    expect: true
-                }
-            ]
-        },
-        {
-            'name': 'Strict object',
-            'rule': ['$.strict', {
-                'a': 'uint'
-            }],
-            'items': [
-                {
-                    inputName: 'Empty object',
-                    inputValue: {},
-                    expect: false
-                },
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: true
-                },
-                {
-                    inputName: 'Object with one mismatch-typed property',
-                    inputValue: { 'a': '123' },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with 2 properties',
-                    inputValue: { 'a': 123, 'b': { 'c': 'ffff' } },
-                    expect: false
-                }
-            ]
-        },
-        {
-            'name': 'Strict object with nested properties',
-            'rule': ['$.strict', {
-                'a': 'uint',
-                'b': {
-                    'c': 'uint'
-                }
-            }],
-            'items': [
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with wrong type in nest',
-                    inputValue: { 'a': 123, 'b': { 'c': 'ffff' } },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with all correct',
-                    inputValue: { 'a': 123, 'b': { 'c': 123 } },
-                    expect: true
-                },
-                {
-                    inputName: 'Object with one more in nested',
-                    inputValue: { 'a': 123, 'b': { 'c': 123, 'd': '1213131' } },
-                    expect: true
-                }
-            ]
-        },
-        {
-            'name': 'Recursively-Strict object with nested properties',
-            'rule': ['$.equal', {
-                'a': 'uint',
-                'b': {
-                    'c': 'uint'
-                }
-            }],
-            'items': [
-                {
-                    inputName: 'Object with one property',
-                    inputValue: { 'a': 123 },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with wrong type in nest',
-                    inputValue: { 'a': 123, 'b': { 'c': 'ffff' } },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with all correct',
-                    inputValue: { 'a': 123, 'b': { 'c': 123 } },
-                    expect: true
-                },
-                {
-                    inputName: 'Object with one more in nested',
-                    inputValue: { 'a': 123, 'b': { 'c': 123, 'd': '1213131' } },
-                    expect: false
-                }
-            ]
-        },
-        {
-            'name': 'Object with from-string modifier',
-            'rule': ['$.string', {
-                'a': 'uint',
-                'b': {
-                    'c': 'uint'
-                }
-            }],
-            'items': [
-                {
-                    inputName: 'Object with all correct',
-                    inputValue: { 'a': 123, 'b': { 'c': 123 } },
-                    expect: true
-                },
-                {
-                    inputName: 'Object with string incorrect-value',
-                    inputValue: { 'a': 123, 'b': { 'c': '123d' } },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with string value',
-                    inputValue: { 'a': '123312312', 'b': { 'c': '123' } },
-                    expect: true
-                }
-            ]
-        },
-        {
-            'name': 'Object with from-string modifier',
-            'rule': ['$.string', {
-                'a': 'uint',
-                'b': {
-                    'c': 'uint'
-                }
-            }],
-            'items': [
-                {
-                    inputName: 'Object with all correct',
-                    inputValue: { 'a': 123, 'b': { 'c': 123 } },
-                    expect: true
-                },
-                {
-                    inputName: 'Object with string incorrect-value',
-                    inputValue: { 'a': 123, 'b': { 'c': '123d' } },
-                    expect: false
-                },
-                {
-                    inputName: 'Object with string value',
-                    inputValue: { 'a': '123312312', 'b': { 'c': '123' } },
-                    expect: true
-                }
-            ]
-        },
-    ]
-};
-
-export default createTestDefinition(testItems);

package/src/test/07-modifiers.ts

@@ -1,220 +0,0 @@
-/**
- * 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.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { createTestDefinition, defaultItemss, ITestSuite } from './abstracts';
-
-const testItems: ITestSuite = {
-
-    name: 'Modifiers',
-    sections: [
-
-        {
-            'name': '$.string',
-            'rule': ['$.string', 'uint32', { 'a': 'uint32' }],
-            'items': [
-                {
-                    inputName: JSON.stringify('123'),
-                    inputValue: '123',
-                    expect: true
-                },
-                {
-                    inputName: JSON.stringify({ 'a': 123 }),
-                    inputValue: { 'a': 123 },
-                    expect: true
-                },
-                {
-                    inputName: JSON.stringify({ 'a': 123 }),
-                    inputValue: { 'a': 123 },
-                    expect: true
-                },
-                ...defaultItemss({
-                    'number 1': true,
-                    'number 0': true
-                })
-            ]
-        },
-        {
-            'name': '$.string standalone',
-            'rule': ['$.and', ['$.string', 'uint32'], 'uint32'],
-            'items': [
-                {
-                    inputName: JSON.stringify('123'),
-                    inputValue: '123',
-                    expect: false
-                }
-            ]
-        },
-        {
-            'name': '$.strict standalone',
-            'rule': ['$.tuple', ['$.strict', {
-                'a': 'string'
-            }], {
-                'a': 'string'
-            }],
-            'items': [
-                {
-                    inputName: JSON.stringify([{ 'a': 'x' }, { 'a': 'c', 'b': 'x' }]),
-                    inputValue: [{ 'a': 'x' }, { 'a': 'c', 'b': 'x' }],
-                    expect: true
-                }
-            ]
-        },
-        {
-            'name': '$.equal standalone',
-            'rule': ['$.and', ['$.equal', {
-                'a': 'any'
-            }], {
-                'a': {
-                    'b': 'string'
-                }
-            }],
-            'items': [
-                {
-                    inputName: JSON.stringify({ 'a': { 'b': 'c', 'd': 'ccc' } }),
-                    inputValue: { 'a': { 'b': 'c', 'd': 'ccc' } },
-                    expect: true
-                }
-            ]
-        },
-        {
-            'name': '$.not with string and literal 0',
-            'rule': ['$.not', 'string', 0],
-            'items': [
-                {
-                    inputName: 'string \'abc\'',
-                    inputValue: 'abc',
-                    expect: false
-                },
-                ...defaultItemss({
-                    'string \'hello\'': false,
-                    'empty string': false,
-                    'number 0': false
-                }, true)
-            ]
-        },
-        {
-            'name': '$.type ',
-            'rule': {
-                'a': ['$.type', 'test:a.b-c', 'int'],
-                'b': '@test:a.b-c',
-            },
-            'items': [
-                {
-                    inputName: 'object {a: 213, b: 321}',
-                    inputValue: {
-                        'a': 213,
-                        'b': 321
-                    },
-                    expect: true
-                },
-                {
-                    inputName: 'object {a: 213, b: "321"}',
-                    inputValue: {
-                        'a': 213,
-                        'b': '321'
-                    },
-                    expect: false
-                },
-                {
-                    inputName: 'object {a: 213, b: "321"}',
-                    inputValue: {
-                        'a': 213,
-                        'b': 777
-                    },
-                    expect: true
-                },
-                ...defaultItemss({}, false)
-            ]
-        },
-        {
-            'name': 'Pre-defined IPv4 Address Checker',
-            'rule': '@ipv4_address',
-            'items': [
-                {
-                    inputName: 'String: 1.1.1.1',
-                    inputValue: '1.1.1.1',
-                    expect: true
-                },
-                {
-                    inputName: 'String: 255.255.255.255',
-                    inputValue: '255.255.255.255',
-                    expect: true
-                },
-                {
-                    inputName: 'String: 0.0.0.0',
-                    inputValue: '0.0.0.0',
-                    expect: true
-                },
-                {
-                    inputName: 'String: 2552.1.1.1',
-                    inputValue: '2552.1.1.1',
-                    expect: false
-                },
-                {
-                    inputName: 'String: 256.1.1.1',
-                    inputValue: '256.1.1.1',
-                    expect: false
-                },
-                {
-                    inputName: 'String: .1.1.1',
-                    inputValue: '.1.1.1',
-                    expect: false
-                },
-                {
-                    inputName: 'object {a: 213, b: 321}',
-                    inputValue: {
-                        'a': 213,
-                        'b': 321
-                    },
-                    expect: false
-                },
-                {
-                    inputName: 'object {a: 213, b: "321"}',
-                    inputValue: {
-                        'a': 213,
-                        'b': '321'
-                    },
-                    expect: false
-                },
-                {
-                    inputName: 'object {a: 213, b: "321"}',
-                    inputValue: {
-                        'a': 213,
-                        'b': 777
-                    },
-                    expect: false
-                },
-                ...defaultItemss({}, false)
-            ]
-        },
-        {
-            'name': '$.type with unsupported characters in type name',
-            'rule': {
-                'a': ['$.type', 'test=123', 'int'],
-                'b': '@test:a',
-            },
-            'items': [
-                {
-                    inputName: 'invalid format',
-                    inputValue: '',
-                    expect: 'throw'
-                }
-            ]
-        },
-    ]
-};
-
-export default createTestDefinition(testItems);

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

@@ -1,151 +0,0 @@
-/**
- * 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.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-    createTestDefinition,
-    defaultItemss,
-    ITestSuite,
-    assertItem,
-    addRule
-} from './abstracts';
-
-const testItems: ITestSuite = {
-
-    name: 'Mappings & Dicts',
-    sections: [
-
-        {
-            'name': JSON.stringify(['$.map', 'string', 'uint32']),
-            'rule': ['$.map', 'string', 'uint32'],
-            'items': [
-                {
-                    inputName: 'all string object',
-                    inputValue: { 'a': '123312312', 'b': 'ccc' },
-                    expect: true
-                },
-                {
-                    inputName: 'all uint32 object',
-                    inputValue: { 'a': 123312312, 'b': 0xCCC },
-                    expect: true
-                },
-                {
-                    inputName: 'all uint32 & string object',
-                    inputValue: { 'a': 123312312, 'b': 0xCCC },
-                    expect: true
-                },
-                {
-                    inputName: 'all uint32 & boolean object',
-                    inputValue: { 'a': 123312312, 'b': false },
-                    expect: false
-                },
-                ...defaultItemss({
-                    'object': true
-                })
-            ]
-        },
-        {
-            'name': JSON.stringify({
-                'a': 'string',
-                '$.map': 'number'
-            }),
-            'rule': {
-                'a': 'string',
-                '$.map': 'number'
-            },
-            'items': [
-                assertItem(
-                    { 'a': '123312312', 'b': 123.3, c: 1232 },
-                    true
-                ),
-                assertItem(
-                    { 'a': '123312312', 'b': 'ccc' },
-                    false
-                ),
-                assertItem(
-                    { 'a': 123312312, 'b': 123.3 },
-                    false
-                ),
-            ]
-        },
-        {
-            'name': JSON.stringify({
-                'a': 'string',
-                'b->{}': 'number'
-            }),
-            'rule': {
-                'a': 'string',
-                'b->{}': 'number'
-            },
-            'items': [
-                assertItem(
-                    { 'a': '123312312', 'b': 'ccc' },
-                    false
-                ),
-                assertItem(
-                    { 'a': 123312312, 'b': 123.3 },
-                    false
-                ),
-                assertItem(
-                    { 'a': '123312312', 'b': { d: 123.3, c: 1232 } },
-                    true
-                ),
-                assertItem(
-                    { 'a': '123312312', 'b': { d: 123.3, c: '1232' } },
-                    false
-                ),
-            ]
-        },
-        addRule(['$.dict', ['a', 'b'], 'string'], [
-            assertItem(
-                { 'a': '123312312', 'b': 'ccc' },
-                true
-            ),
-            assertItem(
-                { 'a': '123312312', 'b': 'ccc', 'c': 123 },
-                true
-            ),
-            assertItem(
-                { 'a': '123312312' },
-                false
-            ),
-            assertItem(
-                { 'a': '123312312', 'c': 'ddd' },
-                false
-            ),
-            assertItem(
-                { 'a': '123312312', 'b': 123.3 },
-                false
-            )
-        ]),
-        addRule(['$.strict', '$.dict', ['a', 'b'], 'string'], [
-            assertItem(
-                { 'a': '123312312', 'b': 'ccc' },
-                true
-            ),
-            assertItem(
-                { 'a': '123312312', 'b': 'ccc', 'c': 123 },
-                false
-            ),
-            assertItem(
-                { 'a': '123312312' },
-                false
-            ),
-        ])
-
-    ]
-};
-
-export default createTestDefinition(testItems);