validno 0.4.4 → 0.4.6

package/dist/tests/types.test.js

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

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

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

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

package/dist/tests/utils/_errors.test.js

@@ -1,47 +0,0 @@
-import { expect, test } from '@jest/globals';
-import _errors from '../../utils/errors';
-test('Тест _errors.getMissingError', () => {
-    const key = 'testKey';
-    const emptyKey = _errors.getMissingError();
-    const okKey = _errors.getMissingError(key);
-    expect(emptyKey).toBe(`Missing value for 'na'`);
-    expect(okKey).toBe(`Missing value for '${key}'`);
-});
-test('Тест _errors.joinErrors', () => {
-    const defaultSeparator = '; ';
-    const customSeparator = '||';
-    const emptyErrorMsg = _errors.joinErrors([]);
-    const oneErrorMsg = _errors.joinErrors(['X']);
-    const multipleErrorMsg = _errors.joinErrors(['X', 'Y', 'Z']);
-    const customSeparatorErrorMsg = _errors.joinErrors(['X', 'Y', 'Z'], customSeparator);
-    expect(emptyErrorMsg).toBe('');
-    expect(oneErrorMsg).toBe('X');
-    expect(multipleErrorMsg).toBe('X' + defaultSeparator + 'Y' + defaultSeparator + 'Z');
-    expect(customSeparatorErrorMsg).toBe('X' + customSeparator + 'Y' + customSeparator + 'Z');
-});
-test('Тест _errors.getErrorDetails', () => {
-    class CustomTest {
-        test() {
-            return true;
-        }
-    }
-    const customObj = new CustomTest();
-    const key = 'key';
-    const errorNull = _errors.getErrorDetails(key, String, null);
-    const errorUndefined = _errors.getErrorDetails(key, Array, undefined);
-    const errorObject = _errors.getErrorDetails(key, Object, []);
-    const errorBoolean = _errors.getErrorDetails(key, Boolean, 190);
-    const errorCustom = _errors.getErrorDetails(key, Object, customObj);
-    const errorUnknown = _errors.getErrorDetails(key, Number, undefined);
-    const okCustom = _errors.getErrorDetails(key, CustomTest, customObj);
-    const getError = (key, expected, received) => {
-        return `Check the type of '${key}': expected ${expected}, received ${received}`;
-    };
-    expect(errorNull).toBe(getError(key, 'String', 'null'));
-    expect(errorUndefined).toBe(getError(key, 'Array', 'undefined'));
-    expect(errorObject).toBe(getError(key, 'Object', 'Array'));
-    expect(errorBoolean).toBe(getError(key, 'Boolean', 'Number'));
-    expect(errorCustom).toBe(getError(key, 'Object', 'CustomTest'));
-    expect(errorUnknown).toBe(getError(key, 'Number', 'undefined'));
-    expect(okCustom).toBe('');
-});

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

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

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

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