validno 0.4.3 → 0.4.4

package/dist/tests/joinErrors.test.js

@@ -0,0 +1,62 @@
+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

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

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

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

package/dist/tests/missing.test.js

@@ -0,0 +1,224 @@
+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

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

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

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

package/dist/tests/onlyKeys.test.js

@@ -0,0 +1,74 @@
+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

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

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

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

package/dist/tests/types.test.js

@@ -0,0 +1,273 @@
+import { Schema } from '../Schema';
+import { describe, expect, test } from '@jest/globals';
+describe('Проверка каждого типа по отдельности', () => {
+    test('Тест String', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: String
+            }
+        });
+        const objOK = {
+            [key]: 'string'
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 1
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+    test('Тест Number', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: Number
+            }
+        });
+        const objOK = {
+            [key]: 111
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 'string'
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+    test('Тест Boolean', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: Boolean
+            }
+        });
+        const objOK = {
+            [key]: true
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 'false'
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+    test('Тест Array', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: Array
+            }
+        });
+        const objOK = {
+            [key]: []
+        };
+        const objOK2 = {
+            [key]: [1, 2, 3]
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const resOK2 = scheme.validate(objOK2);
+        expect(resOK2.ok).toBe(true);
+        expect(resOK2.passed.includes(key)).toBe(true);
+        expect(resOK2.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 'not array'
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+    test('Тест null', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: null
+            }
+        });
+        const objOK = {
+            [key]: null
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 'not null'
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+    test('Тест Date', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: Date
+            }
+        });
+        const objOK = {
+            [key]: new Date()
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 'not date'
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+    test('Тест Object', () => {
+        const key = 'testKey';
+        const scheme = new Schema({
+            [key]: {
+                required: true,
+                type: Object
+            }
+        });
+        const objOK = {
+            [key]: { test: 1 }
+        };
+        const resOK = scheme.validate(objOK);
+        expect(resOK.ok).toBe(true);
+        expect(resOK.passed.includes(key)).toBe(true);
+        expect(resOK.byKeys[key]).toBe(true);
+        const objBad = {
+            [key]: 'not obj'
+        };
+        const resBad = scheme.validate(objBad);
+        expect(resBad.ok).toBe(false);
+        expect(resBad.failed.includes(key)).toBe(true);
+        expect(resBad.passed.includes(key)).toBe(false);
+        expect(resBad.byKeys[key]).toBe(false);
+    });
+});
+describe("Проверка всех типов сразу", () => {
+    test('Тест всех типов с корректными данными', () => {
+        const schema = new Schema({
+            str: {
+                type: String,
+            },
+            obj: {
+                type: Object,
+            },
+            num: {
+                type: Number,
+            },
+            arr: {
+                type: Array,
+            },
+            null: {
+                type: null,
+            },
+            bool: {
+                type: Boolean,
+            },
+            date: {
+                type: Date
+            }
+        });
+        const obj = {
+            str: 'String',
+            obj: {},
+            num: 1,
+            arr: [1, 2, 3],
+            null: null,
+            bool: true,
+            date: new Date()
+        };
+        const res = schema.validate(obj);
+        const arePassed = [];
+        for (const key in obj) {
+            arePassed.push(res.byKeys[key]);
+        }
+        expect(res.ok).toBe(true);
+        expect(arePassed.every(el => el === true)).toBe(true);
+        expect(res.errors.length).toBe(0);
+    });
+    test('Тест всех типов с некорректными данными', () => {
+        const schema = new Schema({
+            str: {
+                type: String,
+            },
+            obj: {
+                type: Object,
+            },
+            num: {
+                type: Number,
+            },
+            arr: {
+                type: Array,
+            },
+            null: {
+                type: null,
+            },
+            bool: {
+                type: Boolean,
+            },
+            date: {
+                type: Date
+            },
+            test: {
+                type: Object,
+                required: true
+            }
+        });
+        const obj = {
+            str: 123,
+            obj: [],
+            num: 'str',
+            arr: null,
+            null: {},
+            bool: new Date(),
+            date: true,
+            test: undefined
+        };
+        const res = schema.validate(obj);
+        expect(res.ok).toBe(false);
+        const areFailed = [];
+        const hasErrorMsg = [];
+        for (const key in obj) {
+            areFailed.push(res.byKeys[key]);
+            hasErrorMsg.push(key in res.errorsByKeys);
+        }
+        expect(areFailed.every(el => el === false)).toBe(true);
+        expect(hasErrorMsg.every(el => el === true)).toBe(true);
+        expect(res.errors.length).toBe(Object.keys(obj).length);
+    });
+});

package/dist/tests/utils/_errors.test.d.ts

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

package/dist/tests/utils/_errors.test.d.ts.map

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