@sprucelabs/schema 25.5.62 → 25.5.66

package/build/esm/__tests__/behavioral/ValidatingSchemaValues.test.js

@@ -1,674 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { test, assert } from '@sprucelabs/test';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import SpruceError from '../../errors/SpruceError.js';
-import validationErrorAssertUtil from '../../tests/validationErrorAssert.utility.js';
-import areSchemaValuesValid from '../../utilities/areSchemaValuesValid.js';
-import buildSchema from '../../utilities/buildSchema.js';
-import isSchemaValid from '../../utilities/isSchemaValid.js';
-import validateSchemaValues from '../../utilities/validateSchemaValues.js';
-const profileImagesSchema = buildSchema({
-    id: 'profileImage',
-    name: 'Profile Image Sizes',
-    description: 'Various sizes that a profile image comes in.',
-    fields: {
-        profile60: {
-            label: '60x60',
-            type: 'text',
-            isRequired: true,
-        },
-        profile150: {
-            label: '150x150',
-            type: 'text',
-            isRequired: true,
-        },
-        'profile60@2x': {
-            label: '60x60',
-            type: 'text',
-            isRequired: true,
-        },
-        'profile150@2x': {
-            label: '150x150',
-            type: 'text',
-            isRequired: true,
-        },
-    },
-});
-const dynamicSchema = buildSchema({
-    id: 'dynamicSchema',
-    name: 'dynamic schema',
-    dynamicFieldSignature: {
-        type: 'text',
-        keyName: 'anything',
-    },
-});
-const personSchema = buildSchema({
-    id: 'testPerson',
-    name: 'A test person',
-    fields: {
-        firstName: {
-            label: 'First name',
-            type: 'text',
-            isRequired: true,
-        },
-        lastName: {
-            type: 'text',
-            isRequired: true,
-        },
-        email: {
-            type: 'text',
-            isRequired: false,
-        },
-        profileImages: {
-            isRequired: true,
-            type: 'schema',
-            options: {
-                schema: profileImagesSchema,
-            },
-        },
-    },
-});
-const personWithFavColorsSchema = buildSchema({
-    id: 'personWithFavColors',
-    fields: {
-        firstName: {
-            type: 'text',
-            isRequired: true,
-        },
-        lastName: {
-            type: 'text',
-            isRequired: true,
-        },
-        favoriteColors: {
-            type: 'text',
-            isArray: true,
-            isRequired: true,
-        },
-    },
-});
-const toolSchema = buildSchema({
-    id: 'tool',
-    fields: {
-        name: {
-            type: 'text',
-            isRequired: true,
-        },
-    },
-});
-const fruitSchema = buildSchema({
-    id: 'fruit',
-    fields: {
-        color: {
-            type: 'select',
-            isRequired: true,
-            options: {
-                choices: [
-                    {
-                        value: 'yellow',
-                        label: 'Yellow',
-                    },
-                    {
-                        value: 'green',
-                        label: 'Green',
-                    },
-                ],
-            },
-        },
-    },
-});
-const versionedToolSchema = buildSchema({
-    id: 'versionedTool',
-    version: '1.0',
-    fields: {
-        name: {
-            type: 'text',
-            isRequired: true,
-        },
-        age: {
-            type: 'number',
-            isRequired: true,
-        },
-    },
-});
-const version2ToolSchema = buildSchema({
-    id: 'versionedTool',
-    version: '2.0',
-    fields: {
-        size: {
-            type: 'text',
-            isRequired: true,
-        },
-    },
-});
-const versionedFruitSchema = buildSchema({
-    id: 'versionedFruit',
-    version: '1.0',
-    fields: {
-        color: {
-            type: 'select',
-            isRequired: true,
-            options: {
-                choices: [
-                    {
-                        value: 'yellow',
-                        label: 'Yellow',
-                    },
-                    {
-                        value: 'green',
-                        label: 'Green',
-                    },
-                ],
-            },
-        },
-    },
-});
-const personWithFavToolsSchema = buildSchema({
-    id: 'personWithFavTools',
-    name: 'Person with favorite tools',
-    fields: {
-        firstName: {
-            type: 'text',
-            isRequired: true,
-        },
-        lastName: {
-            type: 'text',
-        },
-        favoriteTools: {
-            isRequired: true,
-            type: 'schema',
-            isArray: true,
-            options: {
-                schema: toolSchema,
-            },
-        },
-    },
-});
-const personWithFavToolsOrFruitSchema = buildSchema({
-    id: 'personWithFavToolsOrFruit',
-    name: 'Person with favorite tools',
-    fields: {
-        firstName: {
-            type: 'text',
-            isRequired: true,
-        },
-        phone: {
-            type: 'phone',
-        },
-        lastName: {
-            type: 'text',
-        },
-        favoriteToolsOrFruit: {
-            isRequired: true,
-            type: 'schema',
-            isArray: true,
-            options: {
-                schemas: [toolSchema, fruitSchema],
-            },
-        },
-    },
-});
-const versionedPersonWithFavToolsOrFruitSchema = buildSchema({
-    id: 'versionedPersonWithFavToolsOrFruit',
-    name: 'Person with favorite tools',
-    fields: {
-        firstName: {
-            type: 'text',
-            label: 'First name',
-            isRequired: true,
-        },
-        lastName: {
-            type: 'text',
-        },
-        favoriteToolsOrFruit: {
-            isRequired: true,
-            type: 'schema',
-            isArray: true,
-            options: {
-                schemas: [
-                    versionedFruitSchema,
-                    versionedToolSchema,
-                    version2ToolSchema,
-                ],
-            },
-        },
-    },
-});
-const dynamicFieldSchema = buildSchema({
-    id: 'dynamicSchemaValuesTest',
-    dynamicFieldSignature: {
-        type: 'schema',
-        keyName: 'eventName',
-        options: {
-            schema: personSchema,
-        },
-    },
-});
-export default class CanValidateSchemasTest extends AbstractSchemaTest {
-    static beforeEach() {
-        const _super = Object.create(null, {
-            beforeEach: { get: () => super.beforeEach }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.beforeEach.call(this);
-        });
-    }
-    static canValidateBasicSchemaValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => validateSchemaValues(personSchema, {}));
-            assert.doesInclude(err.message, '3 errors');
-            assert.doesInclude(err.message, `1. 'firstName' is required`);
-            assert.doesInclude(err.message, `2. 'lastName' is required`);
-            assert.doesInclude(err.message, `3. 'profileImages' is required`);
-        });
-    }
-    static canValidateSchemaWithArrayValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesThrow(() => validateSchemaValues(personWithFavColorsSchema, {
-                firstName: 'tay',
-                lastName: 'ro',
-            }), /'favoriteColors' is required/gi);
-        });
-    }
-    static typesValidatedValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const values = {
-                firstName: 'Bob',
-                lastName: 'Bob',
-                profileImages: {
-                    profile60: '@',
-                    profile150: '@',
-                    'profile60@2x': '@',
-                    'profile150@2x': '@',
-                },
-            };
-            validateSchemaValues(personSchema, values);
-            assert.isType(values);
-            assert.isType(values.email);
-        });
-    }
-    static canValidateSpecificFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => validateSchemaValues(personSchema, {}, { fields: ['firstName'] }));
-            assert.doesNotInclude(err.message, /lastName/gi);
-        });
-    }
-    static canCheckValidityWithoutThrowing() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isValid = areSchemaValuesValid(personSchema, {});
-            assert.isFalse(isValid);
-        });
-    }
-    static canCheckValidityOnDynamicFieldsWithoutThrowing() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isValid = isSchemaValid(dynamicSchema);
-            assert.isTrue(isValid);
-        });
-    }
-    static canCheckValidityOnSpecificFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isValid = areSchemaValuesValid(personSchema, { firstName: 'test' }, { fields: ['firstName'] });
-            assert.isTrue(isValid);
-        });
-    }
-    static failsOnSpecificFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isValid = areSchemaValuesValid(personSchema, { firstName: 'test' }, { fields: ['lastName'] });
-            assert.isFalse(isValid);
-        });
-    }
-    static passesWithValidPerson() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const person = {
-                firstName: 'firstName',
-                lastName: 'lastName',
-                profileImages: {
-                    profile60: '@',
-                    profile150: '@',
-                    'profile60@2x': '@',
-                    'profile150@2x': '@',
-                },
-            };
-            validateSchemaValues(personSchema, person);
-        });
-    }
-    static failsWithBadSchema() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesThrow(
-            //@ts-ignore
-            () => validateSchemaValues(null, {}), /Invalid schema/);
-        });
-    }
-    static failsWhenValidatingFieldsNotOnSchema() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => validateSchemaValues(personSchema, {
-                taco: 'bravo',
-                firstName: 'first',
-                lastName: 'last',
-                profileImages: {
-                    profile60: '@',
-                    profile150: '@',
-                    'profile60@2x': '@',
-                    'profile150@2x': '@',
-                },
-            }), /does not exist/);
-            validationErrorAssertUtil.assertError(err, {
-                unexpected: ['taco'],
-            });
-            assert.doesInclude(err.message, 'taco');
-        });
-    }
-    static givesInvalidFieldErrorWhenValidatingEmptyArrayNestedSchemas() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => validateSchemaValues(personWithFavToolsSchema, {
-                firstName: 'first',
-                lastName: 'last',
-                favoriteTools: [],
-            }), /'favoriteTools' must have at least 1/);
-            validationErrorAssertUtil.assertError(err, {
-                invalid: ['favoriteTools'],
-            });
-        });
-    }
-    static givesInvalidFieldErrorWhenValidatingNestedSchemas() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => validateSchemaValues(personWithFavToolsSchema, {
-                firstName: 'first',
-                lastName: 'last',
-                //@ts-ignore
-                favoriteTools: [{}],
-            }), /'favoriteTools.name' is required/);
-            validationErrorAssertUtil.assertError(err, {
-                missing: ['favoriteTools.name'],
-            });
-        });
-    }
-    static canValidateNestedArraySchema() {
-        return __awaiter(this, void 0, void 0, function* () {
-            validateSchemaValues(personWithFavToolsSchema, {
-                firstName: 'Tay',
-                favoriteTools: [
-                    {
-                        name: 'Laptop',
-                    },
-                ],
-            });
-        });
-    }
-    static canValidateArrayOfUnionValuesMissingRequired() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesThrow(() => validateSchemaValues(personWithFavToolsOrFruitSchema, {
-                firstName: 'Ryan',
-                favoriteToolsOrFruit: [],
-            }), /'favoriteToolsOrFruit' must have at least 1/gi);
-        });
-    }
-    static canValidateArrayOfUnionValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            validateSchemaValues(personWithFavToolsOrFruitSchema, {
-                firstName: 'Ryan',
-                favoriteToolsOrFruit: [
-                    {
-                        schemaId: 'fruit',
-                        values: {
-                            color: 'green',
-                        },
-                    },
-                    {
-                        schemaId: 'fruit',
-                        values: {
-                            color: 'yellow',
-                        },
-                    },
-                    {
-                        schemaId: 'tool',
-                        values: {
-                            name: 'wrench',
-                        },
-                    },
-                ],
-            });
-        });
-    }
-    static canValidateArrayOfVersionedUnionValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            validateSchemaValues(versionedPersonWithFavToolsOrFruitSchema, {
-                firstName: 'Ryan',
-                favoriteToolsOrFruit: [
-                    {
-                        schemaId: 'versionedFruit',
-                        version: '1.0',
-                        values: {
-                            color: 'green',
-                        },
-                    },
-                    {
-                        schemaId: 'versionedFruit',
-                        version: '1.0',
-                        values: {
-                            color: 'yellow',
-                        },
-                    },
-                    {
-                        schemaId: 'versionedTool',
-                        version: '1.0',
-                        values: {
-                            name: 'wrench',
-                            age: 10,
-                        },
-                    },
-                    {
-                        schemaId: 'versionedTool',
-                        version: '2.0',
-                        values: {
-                            size: 'wrench',
-                        },
-                    },
-                ],
-            });
-        });
-    }
-    static canValidateArrayOfVersionedUnionValuesAndThrowsReallyHelpfulError() {
-        return __awaiter(this, void 0, void 0, function* () {
-            /*Const err =*/
-            assert.doesThrow(() => validateSchemaValues(versionedPersonWithFavToolsOrFruitSchema, {
-                favoriteToolsOrFruit: [
-                    {
-                        schemaId: 'versionedFruit',
-                        version: '1.0',
-                        values: {
-                            color: 'green',
-                        },
-                    },
-                    {
-                        schemaId: 'versionedFruit',
-                        version: '1.0',
-                        values: {
-                            color: 'yellow',
-                        },
-                    },
-                    {
-                        schemaId: 'versionedTool',
-                        version: '1.0',
-                        values: {
-                            size: 'wrench',
-                        },
-                    },
-                    {
-                        schemaId: 'versionedTool',
-                        version: '2.0',
-                        values: {
-                            name: 'wrench',
-                        },
-                    },
-                ],
-            }));
-            // NOTE uncomment here and above to see error output
-            // const message = err.friendlyMessage()
-            // console.log(message)
-            // debugger
-        });
-    }
-    static throwsWhenAddingExtraFieldAtTopLevel() {
-        assert.doesThrow(() => validateSchemaValues(personWithFavToolsOrFruitSchema, {
-            firstName: 'Ryan',
-            doesNotExist: true,
-            favoriteToolsOrFruit: [
-                {
-                    schemaId: 'fruit',
-                    values: {
-                        color: 'green',
-                    },
-                },
-            ],
-        }), /doesNotExist/);
-    }
-    static throwsWhenAddingExtraFieldInNestedSchema() {
-        assert.doesThrow(() => validateSchemaValues(personWithFavToolsOrFruitSchema, {
-            firstName: 'Ryan',
-            favoriteToolsOrFruit: [
-                {
-                    schemaId: 'fruit',
-                    values: {
-                        doesNotExist: true,
-                        color: 'green',
-                    },
-                },
-            ],
-        }), /doesNotExist/);
-    }
-    static validationErrorsAreTyped() {
-        try {
-            validateSchemaValues(personWithFavToolsOrFruitSchema, {
-                firstName: 'Ryan',
-                favoriteToolsOrFruit: [],
-            });
-        }
-        catch (err) {
-            if (err instanceof SpruceError) {
-                if (err.options.code === 'VALIDATION_FAILED') {
-                    const first = err.options.errors[0].code;
-                    assert.isExactType(true);
-                }
-            }
-            else {
-                assert.fail('Bad error returned');
-            }
-        }
-    }
-    static printsSoPretty() {
-        try {
-            validateSchemaValues(personWithFavToolsOrFruitSchema, {
-                //@ts-ignore
-                taco: [],
-                phone: 'satnoehusntah',
-                favoriteToolsOrFruit: [{ schemaId: 'tool', values: { cheba: 'hut' } }],
-            });
-        }
-        catch (err) {
-            this.log(err.message);
-        }
-    }
-    static dynamicSchemasHaveFieldNameInError() {
-        const err = assert.doesThrow(() => validateSchemaValues(dynamicFieldSchema, {
-            //@ts-ignore
-            taco: {
-                //@ts-ignore
-                hey: 'there',
-            },
-        }));
-        assert.doesInclude(err.message, 'taco');
-        assert.doesInclude(err.message, 'hey');
-    }
-    static invalidFieldsGiveDescriptionsOnWhySomethingIsInvalid() {
-        const err = assert.doesThrow(() => validateSchemaValues(personWithFavToolsOrFruitSchema, {
-            phone: 'cheesy',
-        }));
-        assert.doesInclude(err.message, 'US number');
-    }
-}
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateBasicSchemaValues", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateSchemaWithArrayValues", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "typesValidatedValues", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateSpecificFields", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canCheckValidityWithoutThrowing", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canCheckValidityOnDynamicFieldsWithoutThrowing", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canCheckValidityOnSpecificFields", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "failsOnSpecificFields", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "passesWithValidPerson", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "failsWithBadSchema", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "failsWhenValidatingFieldsNotOnSchema", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "givesInvalidFieldErrorWhenValidatingEmptyArrayNestedSchemas", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "givesInvalidFieldErrorWhenValidatingNestedSchemas", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateNestedArraySchema", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateArrayOfUnionValuesMissingRequired", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateArrayOfUnionValues", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateArrayOfVersionedUnionValues", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "canValidateArrayOfVersionedUnionValuesAndThrowsReallyHelpfulError", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "throwsWhenAddingExtraFieldAtTopLevel", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "throwsWhenAddingExtraFieldInNestedSchema", null);
-__decorate([
-    test('validation errors are typed (will always pass, lint will fail)')
-], CanValidateSchemasTest, "validationErrorsAreTyped", null);
-__decorate([
-    test.skip('pretty print of validation test (skip to pass tests)')
-], CanValidateSchemasTest, "printsSoPretty", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "dynamicSchemasHaveFieldNameInError", null);
-__decorate([
-    test()
-], CanValidateSchemasTest, "invalidFieldsGiveDescriptionsOnWhySomethingIsInvalid", null);