validno 0.4.4 → 0.4.5

package/dist/tests/customType.test.js

@@ -1,146 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../Schema';
-class Parent {
-    constructor(value) {
-        this.value = value;
-        this.version = 1;
-    }
-    getV() {
-        return this.version;
-    }
-}
-class Child extends Parent {
-    constructor(value) {
-        super(value);
-        this.isDeep = true;
-    }
-}
-class CustomString extends String {
-    constructor(value) {
-        super(value);
-    }
-    isEmpty() {
-        return this !== undefined && this.length === 0;
-    }
-}
-describe('Тестирование кастомного типа', () => {
-    test('Значения, созданные из кастомных типов, корректно проходят проверку', () => {
-        const keys = ['cust1', 'cust2', 'cust3', 'badKey'];
-        const err = new Error('ops');
-        const parent = new Parent(1);
-        const child = new Child(2);
-        const child2 = new Child(3);
-        const schema = new Schema({
-            [keys[0]]: {
-                type: Error,
-                required: true
-            },
-            [keys[1]]: {
-                type: Parent,
-                required: true
-            },
-            [keys[2]]: {
-                type: Child,
-                required: true
-            },
-        });
-        const obj = {
-            [keys[0]]: err,
-            [keys[1]]: parent,
-            [keys[2]]: child,
-        };
-        const res = schema.validate(obj);
-        const allKeysArePassed = [
-            res.byKeys[keys[0]] === true,
-            res.byKeys[keys[1]] === true,
-            res.byKeys[keys[2]] === true,
-        ].every(k => k === true);
-        expect(res.ok).toBe(true);
-        expect(allKeysArePassed).toBe(true);
-    });
-    test('Дочерний класс не проходит проверку по родительскому классу', () => {
-        const keys = ['cust1', 'cust2', 'cust3'];
-        const parent = new Parent(1);
-        const child = new Child(2);
-        const schema = new Schema({
-            [keys[0]]: {
-                type: Parent,
-                required: true
-            },
-            [keys[1]]: {
-                type: Child,
-                required: true
-            },
-            [keys[2]]: {
-                type: Parent,
-                required: true
-            },
-        });
-        const obj = {
-            [keys[0]]: parent,
-            [keys[1]]: child,
-            [keys[2]]: child,
-        };
-        const res = schema.validate(obj);
-        const allKeysArePassed = [
-            res.byKeys[keys[0]] === true,
-            res.byKeys[keys[1]] === true,
-            res.byKeys[keys[2]] === false,
-        ].every(k => k === true);
-        expect(res.ok).toBe(false);
-        expect(allKeysArePassed).toBe(true);
-        expect(res.failed.includes(keys[2])).toBe(true);
-    });
-    test('Унаследованный класс от String не проходит проверку как String', () => {
-        const keys = ['cust0', 'cust1', 'cust2', 'cust3', 'undef'];
-        const origin = new String('str1');
-        const origin2 = 'str2';
-        const custom = new CustomString('str3');
-        const schema = new Schema({
-            [keys[0]]: {
-                type: String,
-                required: true,
-                title: "test String to String"
-            },
-            [keys[1]]: {
-                type: CustomString,
-                required: true,
-                title: "test CustomString to CustomString"
-            },
-            [keys[2]]: {
-                type: CustomString,
-                required: true,
-                title: "test String to CustomString"
-            },
-            [keys[3]]: {
-                type: String,
-                required: true,
-                title: "test CustomString to String"
-            },
-            [keys[4]]: {
-                type: String,
-                required: true,
-                title: "test undefined to String"
-            },
-        });
-        const obj = {
-            [keys[0]]: origin,
-            [keys[1]]: custom,
-            [keys[2]]: origin2,
-            [keys[3]]: custom,
-        };
-        const res = schema.validate(obj);
-        const allKeysArePassed = [
-            res.byKeys[keys[0]] === true,
-            res.byKeys[keys[1]] === true,
-            res.byKeys[keys[2]] === false,
-            res.byKeys[keys[3]] === false,
-            res.byKeys[keys[4]] === false,
-        ].every(k => k === true);
-        expect(res.ok).toBe(false);
-        expect(allKeysArePassed).toBe(true);
-        expect(res.failed.includes(keys[2])).toBe(true);
-        expect(res.failed.includes(keys[3])).toBe(true);
-        expect(res.failed.includes(keys[4])).toBe(true);
-    });
-});

package/dist/tests/joinErrors.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=joinErrors.test.d.ts.map

package/dist/tests/joinErrors.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"joinErrors.test.d.ts","sourceRoot":"","sources":["../../src/tests/joinErrors.test.ts"],"names":[],"mappings":""}

package/dist/tests/joinErrors.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../Schema';
-describe('Тестирование функции joinErrors', () => {
-    const keys = ['ops1', 'ops2', 'miss'];
-    const schema = new Schema({
-        [keys[0]]: {
-            type: Number,
-            required: true,
-            title: 'titl',
-        },
-        [keys[1]]: {
-            type: String,
-            required: true,
-            title: 'titl',
-        },
-        [keys[2]]: {
-            type: String,
-            required: true,
-            title: 'titl',
-        }
-    });
-    const schema2 = new Schema({});
-    test('Пустая строка при отсутствии ошибок', () => {
-        const objOk = {
-            [keys[0]]: 222,
-            [keys[1]]: 'str',
-            [keys[2]]: 'here'
-        };
-        const res = schema.validate(objOk);
-        expect(res.ok).toBe(true);
-        expect(res.joinErrors()).toBe("");
-    });
-    test('Пустая строка при отсутствии ошибок и пустой схеме', () => {
-        const objOk = {
-            [keys[0]]: 222,
-            [keys[1]]: 'str',
-            [keys[2]]: 'here'
-        };
-        const res = schema2.validate(objOk);
-        expect(res.ok).toBe(true);
-        expect(res.joinErrors()).toBe("");
-    });
-    test('Корректная строка при наличии ошибок', () => {
-        const unexpectedKey = 'unexpectedKey';
-        const objOk = {
-            [keys[0]]: '222',
-            [keys[1]]: 1,
-            [unexpectedKey]: 'not supposed to be here)'
-        };
-        const res = schema.validate(objOk);
-        const errorsStr = res.joinErrors();
-        const stringHasAllKeys = [
-            errorsStr.includes(keys[0]),
-            errorsStr.includes(keys[1]),
-            errorsStr.includes(keys[2]),
-            !errorsStr.includes(unexpectedKey)
-        ].every(k => k === true);
-        expect(res.ok).toBe(false);
-        expect(errorsStr.length).toBeGreaterThan(5);
-        expect(stringHasAllKeys).toBe(true);
-    });
-});

package/dist/tests/missing.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=missing.test.d.ts.map

package/dist/tests/missing.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"missing.test.d.ts","sourceRoot":"","sources":["../../src/tests/missing.test.ts"],"names":[],"mappings":""}

package/dist/tests/missing.test.js

@@ -1,224 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../Schema';
-import _errors from '../utils/errors';
-describe('Тестирование обработки пропущенных свойста', () => {
-    test('Отсутствующий ключ правильно отображается в результате', () => {
-        const missedKey = 'testKey';
-        const missedKey2 = 'testKey2';
-        const okKey = 'okKey';
-        const scheme = new Schema({
-            [missedKey]: {
-                required: true,
-                type: String
-            },
-            [missedKey2]: {
-                required: true,
-                type: String
-            },
-            [okKey]: {
-                required: true,
-                type: String
-            }
-        });
-        const obj = {
-            [okKey]: 'string'
-        };
-        const result = scheme.validate(obj);
-        expect(result).toEqual({
-            ok: false,
-            failed: [missedKey, missedKey2],
-            missed: [missedKey, missedKey2],
-            errors: [
-                _errors.getMissingError(missedKey),
-                _errors.getMissingError(missedKey2)
-            ],
-            passed: [okKey],
-            byKeys: {
-                [missedKey]: false,
-                [missedKey2]: false,
-                [okKey]: true
-            },
-            errorsByKeys: {
-                [missedKey]: [_errors.getMissingError(missedKey)],
-                [missedKey2]: [_errors.getMissingError(missedKey2)]
-            }
-        });
-    });
-    test('Присутствующий ключ правильно отображается в результате', () => {
-        const key = 'testKey';
-        const key2 = 'testKey2';
-        const scheme = new Schema({
-            [key]: {
-                required: true,
-                type: String
-            },
-            [key2]: {
-                required: true,
-                type: String
-            }
-        });
-        const obj = {
-            [key]: 'string',
-            [key2]: 'string'
-        };
-        const result = scheme.validate(obj);
-        expect(result).toEqual({
-            ok: true,
-            failed: [],
-            missed: [],
-            errors: [],
-            passed: [key, key2],
-            byKeys: {
-                [key]: true,
-                [key2]: true
-            },
-            errorsByKeys: {}
-        });
-    });
-    test('Отсутствующий необязательный ключ правильно отображается в результах', () => {
-        const key = 'testKey';
-        const key2 = 'testKey2';
-        const scheme = new Schema({
-            [key]: {
-                required: false,
-                type: String
-            },
-            [key2]: {
-                required: true,
-                type: String
-            }
-        });
-        const obj = {
-            [key2]: 'string'
-        };
-        const result = scheme.validate(obj);
-        expect(result).toEqual({
-            ok: true,
-            failed: [],
-            missed: [],
-            errors: [],
-            passed: [key, key2],
-            byKeys: {
-                [key]: true,
-                [key2]: true
-            },
-            errorsByKeys: {}
-        });
-    });
-    test('Отсутствующие ключи в deep объекте корректно отображаются в результате', () => {
-        const scheme = new Schema({
-            parent: {
-                childA: {
-                    childA1: {
-                        type: String,
-                        required: true
-                    },
-                    childA2: {
-                        type: String,
-                        required: true
-                    }
-                },
-                childB: {
-                    type: String,
-                    required: true
-                }
-            },
-            parentBMissing: {
-                type: String,
-                required: true
-            },
-            keyOk: {
-                type: String,
-                required: true
-            },
-            notRequired: {
-                type: String,
-                required: false
-            }
-        });
-        const obj = {
-            parent: {
-                childB: 'str'
-            },
-            keyOk: 'x'
-        };
-        const result = scheme.validate(obj);
-        result.failed.sort();
-        result.missed.sort();
-        result.errors.sort();
-        result.passed.sort();
-        expect(result).toEqual({
-            ok: false,
-            failed: ['parent', 'parent.childA', 'parent.childA.childA1', 'parent.childA.childA2', 'parentBMissing'].sort(),
-            missed: ['parent.childA.childA1', 'parent.childA.childA2', 'parentBMissing'].sort(),
-            errors: [
-                "Missing value for 'parent.childA.childA1'",
-                "Missing value for 'parent.childA.childA2'",
-                "Missing value for 'parentBMissing'",
-            ].sort(),
-            passed: ['parent.childB', 'keyOk', 'notRequired'].sort(),
-            byKeys: {
-                parent: false,
-                'parent.childA': false,
-                'parent.childA.childA1': false,
-                'parent.childA.childA2': false,
-                'parent.childB': true,
-                parentBMissing: false,
-                keyOk: true,
-                notRequired: true
-            },
-            errorsByKeys: {
-                'parent.childA.childA1': ["Missing value for 'parent.childA.childA1'"],
-                'parent.childA.childA2': ["Missing value for 'parent.childA.childA2'"],
-                parentBMissing: ["Missing value for 'parentBMissing'"]
-            }
-        });
-    });
-});
-describe('Свойство required по умолчанию равно true', () => {
-    test('Свойство required по умолчанию равно true', () => {
-        const scheme = new Schema({
-            testKey: {
-                type: String
-            }
-        });
-        const obj = {};
-        const result = scheme.validate(obj);
-        expect(result).toEqual({
-            ok: false,
-            failed: ['testKey'],
-            missed: ['testKey'],
-            errors: ["Missing value for 'testKey'"],
-            passed: [],
-            byKeys: {
-                testKey: false
-            },
-            errorsByKeys: {
-                testKey: ["Missing value for 'testKey'"]
-            }
-        });
-    });
-    test('Свойство required=true корректно обрабатывается', () => {
-        const scheme = new Schema({
-            testKey: {
-                type: String,
-                required: true
-            }
-        });
-        const obj = {};
-        const result = scheme.validate(obj);
-        expect(result).toEqual({
-            ok: false,
-            failed: ['testKey'],
-            missed: ['testKey'],
-            errors: ["Missing value for 'testKey'"],
-            passed: [],
-            byKeys: {
-                testKey: false
-            },
-            errorsByKeys: {
-                testKey: ["Missing value for 'testKey'"]
-            }
-        });
-    });
-});

package/dist/tests/onlyKeys.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=onlyKeys.test.d.ts.map

package/dist/tests/onlyKeys.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onlyKeys.test.d.ts","sourceRoot":"","sources":["../../src/tests/onlyKeys.test.ts"],"names":[],"mappings":""}

package/dist/tests/onlyKeys.test.js

@@ -1,74 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../Schema';
-describe('Параметр onlyKeys возвращает корректный результат валидации объекта', () => {
-    const schema = new Schema({
-        str: {
-            type: String,
-            required: true,
-        },
-        numb: {
-            type: Number,
-            required: true
-        },
-        obj: {
-            deep1: {
-                type: Boolean,
-                required: true
-            },
-            deep2: {
-                type: Boolean,
-                required: false
-            }
-        }
-    });
-    test('Проверяются все ключи, если !onlyKeys', () => {
-        const obj = {
-            str: 'string',
-            numb: 1,
-            obj: {
-                deep1: true,
-                deep2: true
-            }
-        };
-        const result = schema.validate(obj);
-        expect(result.ok).toBe(true);
-        expect(result.passed.length).toBe(5);
-    });
-    test('Проверяются только необходимые ключи, если представлен onlyKeys (string)', () => {
-        const obj = {
-            str: 'string',
-            numb: 1,
-            obj: {
-                deep1: true,
-                deep2: true
-            }
-        };
-        const keyToCheck = 'str';
-        const result = schema.validate(obj, keyToCheck);
-        expect(result.ok).toBe(true);
-        expect(result.passed.length).toBe(1);
-        expect(result.passed.includes(keyToCheck)).toBe(true);
-        expect(result.missed.length).toBe(0);
-        expect(result.failed.length).toBe(0);
-        expect(result.errors.length).toBe(0);
-    });
-    test('Проверяются только необходимые ключи, если представлен onlyKeys (string[])', () => {
-        const obj = {
-            str: 'string',
-            numb: 1,
-            obj: {
-                deep1: true,
-                deep2: true
-            }
-        };
-        const keyToCheck = ['str', 'obj'];
-        const result = schema.validate(obj, keyToCheck);
-        expect(result.ok).toBe(true);
-        expect(result.passed.length).toBe(4);
-        expect(result.passed.includes(keyToCheck[0])).toBe(true);
-        expect(result.passed.includes(keyToCheck[1])).toBe(true);
-        expect(result.missed.length).toBe(0);
-        expect(result.failed.length).toBe(0);
-        expect(result.errors.length).toBe(0);
-    });
-});

package/dist/tests/types.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.test.d.ts.map

package/dist/tests/types.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.test.d.ts","sourceRoot":"","sources":["../../src/tests/types.test.ts"],"names":[],"mappings":""}