validno 0.1.8 → 0.1.10

package/tests/missing.test.js

@@ -1,131 +0,0 @@
-import {describe, expect, test} from '@jest/globals';
-import { Schema } from '../dist/Schema.js';
-import _errors from '../dist/utils/errors.js';
-
-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: {
-                [okKey]: [],
-                [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: {
-                [key]: [],
-                [key2]: []
-            }
-        })
-    })
-
-    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: {
-                [key]: [],
-                [key2]: []
-            }
-        })
-    })
-})

package/tests/types.test.js

@@ -1,316 +0,0 @@
-import {describe, expect, test} from '@jest/globals';
-import { Schema } from '../dist/Schema.js';
-
-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)
-        expect(res.ok).toBe(true)
-        const arePassed = []
-        for (const key in obj) {
-            arePassed.push(res.byKeys[key])
-        }
-
-        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)
-    })
-})