@nolwenture/formik-jsonschema-form 0.26.8 → 1.0.0-beta.2

package/dist/esm/utils/__tests/createValidationSchema.test.js

@@ -1,944 +0,0 @@
-import { ageFieldDefinition } from "../../sampleData/ageFieldDefinition";
-import { createValidationSchema } from "../createValidationSchema";
-const exampleSchema = {
-    title: "TITLE",
-    required: ["name", "age", "feeling"],
-    properties: {
-        name: { type: "string", title: "Full name" },
-        age: { $ref: "#/definitions/age" },
-        feeling: { type: "boolean", title: "Feeling happy today?" },
-        arrayOfObject: {
-            type: "array",
-            title: "Array of objects",
-            items: {
-                type: "object",
-                title: "Favourites",
-                required: ["favouriteFood"],
-                properties: {
-                    favouriteFood: { type: "string", title: "Favourite food" },
-                    favouriteSong: { type: "string", title: "Favourite song" },
-                },
-            },
-            additionalItems: {
-                type: "object",
-                title: "Second favourites",
-                required: ["anotherFavouriteSong"],
-                properties: {
-                    anotherFavouriteFood: {
-                        type: "string",
-                        title: "Another favourite food",
-                    },
-                    anotherFavouriteSong: {
-                        type: "string",
-                        title: "Another favourite song",
-                    },
-                },
-            },
-        },
-        nestedObject: {
-            type: "object",
-            title: "Nested Object",
-            required: ["tasks"],
-            properties: {
-                hobbies: { type: "string", title: "Hobbies" },
-                tasks: { type: "string", title: "Tasks" },
-            },
-        },
-    },
-    definitions: {
-        age: ageFieldDefinition,
-    },
-};
-const simpleExampleSchema = {
-    title: "TITLE",
-    required: ["lastName"],
-    properties: {
-        firstName: { type: "string", title: "First name" },
-        lastName: { type: "string", title: "Last name" },
-        age: { type: "number", title: "Age" },
-        drinksCoffee: { type: "boolean", title: "Do you drink coffee?" },
-        simpleArray: {
-            type: "array",
-            title: "Simple array",
-            items: [{ type: "string" }],
-        },
-    },
-};
-const dependenciesExampleSchema = {
-    properties: {
-        dependencyField: { type: "string" },
-        dependencySelect: {
-            type: "string",
-            oneOf: [
-                { const: "one", title: "One" },
-                { const: "two", title: "Two" },
-            ],
-        },
-    },
-    dependencies: {
-        dependencyField: {
-            properties: {
-                dependantField: { type: "string" },
-            },
-            required: ["dependantField"],
-        },
-        dependencySelect: {
-            oneOf: [
-                {
-                    properties: {
-                        dependencySelect: {
-                            enum: ["one"],
-                        },
-                    },
-                },
-                {
-                    properties: {
-                        dependencySelect: {
-                            enum: ["two"],
-                        },
-                        dependantOnTwo: {
-                            type: "string",
-                        },
-                    },
-                    required: ["dependantOnTwo"],
-                },
-            ],
-        },
-    },
-};
-const ifThenElseExampleSchema = {
-    type: "object",
-    properties: {
-        allOfBool1: { type: "boolean" },
-        allOfBool2: { type: "boolean" },
-    },
-    allOf: [
-        {
-            if: {
-                properties: {
-                    allOfBool1: { const: true },
-                },
-            },
-            then: {
-                properties: {
-                    firstTrueRequiredField: { type: "string" },
-                },
-                required: ["firstTrueRequiredField"],
-            },
-            else: {
-                properties: {
-                    firstFalseRequiredField: { type: "string" },
-                },
-                required: ["firstFalseRequiredField"],
-            },
-        },
-        {
-            if: {
-                properties: {
-                    allOfBool1: { const: false },
-                    allOfBool2: { const: false },
-                },
-            },
-            then: {
-                properties: {
-                    bothFalseRequiredField: { type: "string" },
-                },
-                required: ["bothFalseRequiredField"],
-            },
-            else: {
-                properties: {
-                    oneOrMoreTrueRequiredField: { type: "string" },
-                },
-                required: ["oneOrMoreTrueRequiredField"],
-            },
-        },
-    ],
-};
-const allOfExample = {
-    type: "object",
-    properties: {
-        customerType: {
-            type: "string",
-            oneOf: [
-                { const: "BUSINESS", title: "Business" },
-                { const: "INDIVIDUAL", title: "Individual" },
-                { const: "UNKNOWN", title: "Unknown" },
-            ],
-        },
-    },
-    allOf: [
-        {
-            if: { properties: { customerType: { const: "BUSINESS" } } },
-            then: {
-                properties: {
-                    businessName: { type: "string", title: "Company name" },
-                    code: { type: "string", title: "Code" },
-                    notRequired: { type: "string", title: "Not required" },
-                    address: { $ref: "#/definitions/address" },
-                },
-                required: ["businessName", "code", "address"],
-            },
-        },
-        {
-            if: { properties: { customerType: { const: "INDIVIDUAL" } } },
-            then: {
-                properties: {
-                    firstName: { type: "string", title: "First name" },
-                    code: { type: "number", title: "Code" },
-                    address: { $ref: "#/definitions/address" },
-                },
-                required: ["firstName", "code", "address"],
-            },
-        },
-        {
-            if: { properties: { customerType: { const: "UNKNOWN" } } },
-            then: {
-                properties: {
-                    newCustomer: { type: "boolean", title: "New customer" },
-                    code: { type: "boolean", title: "Code" },
-                    extraField: { type: "number", title: "Extra field" },
-                    address: { $ref: "#/definitions/address" },
-                },
-                required: ["newCustomer", "code", "address"],
-            },
-        },
-    ],
-    definitions: {
-        address: {
-            type: "object",
-            required: ["streetName", "city", "country"],
-            properties: {
-                streetName: {
-                    type: "string",
-                    title: "Street name",
-                },
-                city: {
-                    type: "string",
-                    title: "Town/City",
-                },
-                postcode: {
-                    type: "string",
-                    title: "Postcode",
-                },
-                state: {
-                    type: "string",
-                    title: "State/Province/Region",
-                },
-                country: {
-                    type: "string",
-                    title: "Country",
-                },
-            },
-        },
-    },
-};
-const anyOfExample = (required = []) => ({
-    type: "object",
-    title: "",
-    required,
-    properties: {
-        warningSymbols: {
-            type: "array",
-            anyOf: [
-                {
-                    const: "GHS01",
-                    title: "Räjähtävä",
-                },
-                {
-                    const: "GHS02",
-                    title: "Syttyvä",
-                },
-                {
-                    const: "GHS03",
-                    title: "Hapettava",
-                },
-                {
-                    const: "GHS04",
-                    title: "Paineen alaiset kaasut",
-                },
-                {
-                    const: "GHS05",
-                    title: "Syövyttävä",
-                },
-                {
-                    const: "GHS06",
-                    title: "Välittömästi myrkyllinen",
-                },
-                {
-                    const: 5678,
-                    title: "Haitallinen / ärsyttävä / herkistävä / vaarallinen otsonikerrokselle",
-                },
-                {
-                    const: 6789,
-                    title: "Vakava terveysvaara",
-                },
-                {
-                    const: 7890,
-                    title: "Ympäristölle vaarallinen",
-                },
-            ],
-            items: {
-                type: "string",
-            },
-            uniqueItems: true,
-        },
-    },
-});
-const nestedRequiredConditionalExampleSchema = {
-    type: "object",
-    properties: {
-        textField: { type: "string" },
-        checkbox: { type: "boolean" },
-    },
-    allOf: [
-        {
-            if: { properties: { checkbox: { const: true } } },
-            then: {
-                properties: {
-                    myObject: {
-                        type: "object",
-                        properties: {
-                            foo: { type: "string" },
-                            nestedObject: {
-                                type: "object",
-                                properties: { nestedFoo: { type: "string" } },
-                                required: ["nestedFoo"],
-                            },
-                        },
-                        required: ["foo"],
-                    },
-                },
-                required: ["myObject"],
-            },
-        },
-    ],
-};
-describe("Create Validation Schema", () => {
-    function listErrors(schema, data, definitions) {
-        const yupSchema = createValidationSchema(schema, definitions);
-        try {
-            // Cannot be strict, since forms always use string based values
-            yupSchema.validateSync(data, { abortEarly: false, strict: false });
-        }
-        catch (err) {
-            const error = err;
-            return error?.inner?.map((e, i) => `${e.path}: ${error.errors[i].replace(e?.path ?? "", "").trim()}`);
-        }
-    }
-    it("creates yup validationSchema based on given JSON schema", async () => {
-        const result = createValidationSchema(exampleSchema);
-        const expected = result.isValidSync({
-            name: "Jane",
-            age: 54,
-            feeling: false,
-            arrayOfObject: [
-                { favouriteFood: "Pizza!", favouriteSong: undefined },
-                {
-                    anotherFavouriteFood: undefined,
-                    anotherFavouriteSong: "On the turning away",
-                },
-            ],
-            nestedObject: {
-                hobbies: undefined,
-                tasks: "buy groceries",
-            },
-        });
-        expect(expected).toEqual(true);
-    });
-    it("throws error when required input is missing", async () => {
-        const result = createValidationSchema(simpleExampleSchema);
-        await expect(() => result.validate({
-            firstName: "Jane",
-            lastName: undefined,
-            age: 55,
-        })).rejects.toThrow("Required");
-    });
-    it("throws error when given input is not matching defined type", async () => {
-        const result = createValidationSchema(simpleExampleSchema);
-        // for 'number' type
-        await expect(() => result.validate({
-            firstName: "Ella",
-            lastName: "Myller",
-            age: true,
-            drinksCoffee: false,
-            simpleArray: [],
-        }, { strict: true })).rejects.toThrow("age must be a `number` type, but the final value was: `true`.");
-        // for 'string' type
-        await expect(() => result.validate({
-            firstName: 123,
-            lastName: "Myller",
-            age: 17,
-            drinksCoffee: false,
-            simpleArray: [],
-        }, { strict: true })).rejects.toThrow("firstName must be a `string` type, but the final value was: `123`.");
-        // for 'boolean' type
-        await expect(() => result.validate({
-            firstName: "Ella",
-            lastName: "Myller",
-            age: 17,
-            drinksCoffee: "Well, sometimes...",
-            simpleArray: [],
-        }, { strict: true })).rejects.toThrow('drinksCoffee must be a `boolean` type, but the final value was: `"Well, sometimes..."`.');
-        // for 'array' type
-        await expect(() => result.validate({
-            firstName: "Ella",
-            lastName: "Myller",
-            age: 17,
-            drinksCoffee: false,
-            simpleArray: "Hello :)",
-        }, { strict: true })).rejects.toThrow("Required");
-    });
-    describe("Conditionals", () => {
-        it("generates validation for dependencies without oneOf", () => {
-            const result = createValidationSchema(dependenciesExampleSchema);
-            const invalid = result.isValidSync({
-                dependencyField: "Hello",
-            });
-            const valid = result.isValidSync({
-                dependencyField: "Hello",
-                dependantField: "Hi",
-            });
-            expect(invalid).toEqual(false);
-            expect(valid).toEqual(true);
-        });
-        it("generates validation for dependencies with oneOf", () => {
-            const result = createValidationSchema(dependenciesExampleSchema);
-            const noDependantFields = result.isValidSync({
-                dependencySelect: "one",
-            });
-            const invalidWithDependantFields = result.isValidSync({
-                dependencySelect: "two",
-            });
-            const validWithDependantFields = result.isValidSync({
-                dependencySelect: "two",
-                dependantOnTwo: "value",
-            });
-            expect(noDependantFields).toEqual(true);
-            expect(invalidWithDependantFields).toEqual(false);
-            expect(validWithDependantFields).toEqual(true);
-        });
-        it("generates validation for if-then-else", () => {
-            const result = createValidationSchema(ifThenElseExampleSchema);
-            const bothFalseInvalid1 = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: false,
-            });
-            const bothFalseInvalid2 = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: false,
-                firstFalseRequiredField: ".",
-            });
-            const bothFalseInvalid3 = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: false,
-                bothFalseRequiredField: ".",
-            });
-            const bothFalseValid = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: false,
-                firstFalseRequiredField: ".",
-                bothFalseRequiredField: ".",
-            });
-            const firstFalseInvalid1 = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: true,
-            });
-            const firstFalseInvalid2 = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: true,
-                firstFalseRequiredField: ".",
-            });
-            const firstFalseInvalid3 = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: true,
-                oneOrMoreTrueRequiredField: ".",
-            });
-            const firstFalseValid = result.isValidSync({
-                allOfBool1: false,
-                allOfBool2: true,
-                firstFalseRequiredField: ".",
-                oneOrMoreTrueRequiredField: ".",
-            });
-            const firstTrueInvalid1 = result.isValidSync({
-                allOfBool1: true,
-                allOfBool2: false,
-            });
-            const firstTrueInvalid2 = result.isValidSync({
-                allOfBool1: true,
-                allOfBool2: false,
-                firstTrueRequiredField: ".",
-            });
-            const firstTrueInvalid3 = result.isValidSync({
-                allOfBool1: true,
-                allOfBool2: false,
-                oneOrMoreTrueRequiredField: ".",
-            });
-            const firstTrueValid = result.isValidSync({
-                allOfBool1: true,
-                allOfBool2: false,
-                firstTrueRequiredField: ".",
-                oneOrMoreTrueRequiredField: ".",
-            });
-            expect(bothFalseInvalid1).toEqual(false);
-            expect(bothFalseInvalid2).toEqual(false);
-            expect(bothFalseInvalid3).toEqual(false);
-            expect(bothFalseValid).toEqual(true);
-            expect(firstFalseInvalid1).toEqual(false);
-            expect(firstFalseInvalid2).toEqual(false);
-            expect(firstFalseInvalid3).toEqual(false);
-            expect(firstFalseValid).toEqual(true);
-            expect(firstTrueInvalid1).toEqual(false);
-            expect(firstTrueInvalid2).toEqual(false);
-            expect(firstTrueInvalid3).toEqual(false);
-            expect(firstTrueValid).toEqual(true);
-        });
-        it("generates validation for if-then", async () => {
-            const faultyBusiness = listErrors(allOfExample, {
-                customerType: "BUSINESS",
-            });
-            expect(faultyBusiness).toEqual(expect.arrayContaining([
-                "address.country: Required",
-                "address.city: Required",
-                "address.streetName: Required",
-                "businessName: Required",
-                "code: Required",
-            ]));
-            const business = listErrors(allOfExample, {
-                customerType: "BUSINESS",
-                businessName: ".",
-                code: ".",
-                address: {
-                    streetName: ".",
-                    city: ".",
-                    country: ".",
-                },
-            });
-            expect(business).toEqual(undefined);
-            const faultyIndividual = listErrors(allOfExample, {
-                customerType: "INDIVIDUAL",
-            });
-            expect(faultyIndividual).toEqual(expect.arrayContaining([
-                "address.country: Required",
-                "address.city: Required",
-                "address.streetName: Required",
-                "firstName: Required",
-                "code: Required",
-            ]));
-            const individual = listErrors(allOfExample, {
-                customerType: "INDIVIDUAL",
-                firstName: ".",
-                code: 123,
-                address: {
-                    streetName: ".",
-                    city: ".",
-                    country: ".",
-                },
-            });
-            expect(individual).toEqual(undefined);
-            const faultyUnknown = listErrors(allOfExample, {
-                customerType: "UNKNOWN",
-            });
-            expect(faultyUnknown).toEqual(expect.arrayContaining([
-                "address.country: Required",
-                "address.city: Required",
-                "address.streetName: Required",
-                "newCustomer: Required",
-                "code: Required",
-            ]));
-            const unknown = listErrors(allOfExample, {
-                customerType: "UNKNOWN",
-                newCustomer: true,
-                code: false,
-                address: {
-                    streetName: ".",
-                    city: ".",
-                    country: ".",
-                },
-            });
-            expect(unknown).toEqual(undefined);
-            const yupSchema = createValidationSchema(allOfExample);
-            // Makes sure the context resets between function calls.
-            // eslint-disable-next-line
-            // @ts-expect-error
-            expect(yupSchema.fields.code.deps.length).toEqual(3);
-        });
-        it("generates validation for conditional objects with nested validations", () => {
-            const result = createValidationSchema(nestedRequiredConditionalExampleSchema);
-            const isValidWhenConditionNotNet = result.isValidSync({
-                checkbox: false,
-            });
-            const isNotValidWhenConditionMetAndMissingRequiredFields = result.isValidSync({
-                checkbox: true,
-            });
-            const isValidWhenConditionMetAndRequiredFieldsAreFilled = result.isValidSync({
-                checkbox: true,
-                myObject: {
-                    foo: ".",
-                    nestedObject: {
-                        nestedFoo: ".",
-                    },
-                },
-            });
-            expect(isValidWhenConditionNotNet).toEqual(true);
-            expect(isNotValidWhenConditionMetAndMissingRequiredFields).toEqual(false);
-            expect(isValidWhenConditionMetAndRequiredFieldsAreFilled).toEqual(true);
-        });
-    });
-    describe("Array", () => {
-        const createArraySchema = ({ items, additionalItems, }) => ({
-            title: "Array of objects Schema",
-            required: ["arrayOfObjects"],
-            properties: {
-                arrayOfObjects: {
-                    type: "array",
-                    title: "A list of fixed items",
-                    items,
-                    ...(additionalItems ? { additionalItems } : {}),
-                },
-            },
-        });
-        it("requires fields with array items and additionalItems", async () => {
-            const arraySchema = createArraySchema({
-                items: [
-                    { title: "A string value", type: "string" },
-                    { title: "An integer value", type: "integer" },
-                    { title: "A number value", type: "number" },
-                    {
-                        title: "An arrayContaining value",
-                        type: "array",
-                        items: [{ title: "A string value", type: "string" }],
-                    },
-                    { title: "a boolean value", type: "boolean" },
-                    {
-                        type: "object",
-                        title: "User",
-                        required: ["name"],
-                        properties: {
-                            name: { type: "string", title: "Name" },
-                            age: { type: "number", title: "Age" },
-                        },
-                    },
-                ],
-                additionalItems: {
-                    title: "Additional item",
-                    type: "number",
-                },
-            });
-            const faultyItem1 = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    ["array"],
-                    123.123,
-                    456,
-                    ["array"],
-                    false,
-                    { name: "John", age: 27 },
-                ],
-            });
-            expect(faultyItem1).toEqual([
-                'arrayOfObjects[0]: must be a `string` type, but the final value was: `[\n  "\\"array\\""\n]`.',
-            ]);
-            const faultyItem2 = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    "string",
-                    "not a number",
-                    456,
-                    ["array"],
-                    false,
-                    { name: "John", age: 27 },
-                ],
-            });
-            expect(faultyItem2).toEqual([
-                'arrayOfObjects[1]: must be a `number` type, but the final value was: `NaN` (cast from the value `"not a number"`).',
-            ]);
-            const faultyItem3 = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    "string",
-                    123.123,
-                    false,
-                    ["array"],
-                    false,
-                    { name: "John", age: 27 },
-                ],
-            });
-            expect(faultyItem3).toEqual([
-                "arrayOfObjects[2]: must be a `number` type, but the final value was: `NaN` (cast from the value `false`).",
-            ]);
-            const faultyItem4 = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    "string",
-                    123.123,
-                    456,
-                    { id: 123 },
-                    false,
-                    { name: "John", age: 27 },
-                ],
-            });
-            expect(faultyItem4).toEqual(["arrayOfObjects[3]: Required"]);
-            const faultyItem5 = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    "string",
-                    123.123,
-                    456,
-                    ["array"],
-                    3.154,
-                    { name: "John", age: 27 },
-                ],
-            });
-            expect(faultyItem5).toEqual([
-                "arrayOfObjects[4]: must be a `boolean` type, but the final value was: `3.154`.",
-            ]);
-            const faultyItem6 = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    "string",
-                    123.123,
-                    456,
-                    ["array"],
-                    false,
-                    "faulty value",
-                ],
-            });
-            expect(faultyItem6).toEqual([
-                'arrayOfObjects[5]: must be a `object` type, but the final value was: `"faulty value"`.',
-            ]);
-            const objectPropertyRequired = listErrors(arraySchema, {
-                arrayOfObjects: ["string", 123.123, 456, ["array"], false, { age: 27 }],
-            });
-            expect(objectPropertyRequired).toEqual([
-                "arrayOfObjects[5].name: Required",
-            ]);
-            const allRequired = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    undefined,
-                    undefined,
-                    undefined,
-                    [],
-                    undefined,
-                    undefined,
-                ],
-            });
-            expect(allRequired).toEqual([
-                "arrayOfObjects[0]: Required",
-                "arrayOfObjects[1]: Required",
-                "arrayOfObjects[2]: Required",
-                "arrayOfObjects[3]: Required",
-                "arrayOfObjects[4]: Required",
-                "arrayOfObjects[5].name: Required",
-            ]);
-            const correct = listErrors(arraySchema, {
-                arrayOfObjects: [
-                    "string",
-                    123.123,
-                    456,
-                    ["array"],
-                    false,
-                    { name: "John", age: 27 },
-                ],
-            });
-            expect(correct).toEqual(undefined);
-        });
-        it("required fields with array items only", async () => {
-            const arraySchema = createArraySchema({
-                items: [
-                    { title: "A string value", type: "string" },
-                    { title: "An integer value", type: "integer" },
-                    { title: "A boolean value", type: "boolean" },
-                    { title: "A number value", type: "number" },
-                ],
-            });
-            const faulty = listErrors(arraySchema, {
-                arrayOfObjects: ["name", undefined, undefined, {}],
-            });
-            expect(faulty).toEqual([
-                "arrayOfObjects[1]: Required",
-                "arrayOfObjects[2]: Required",
-                "arrayOfObjects[3]: must be a `number` type, but the final value was: `NaN` (cast from the value `{}`).",
-            ]);
-            const coprrecorrect = listErrors(arraySchema, {
-                arrayOfObjects: ["name", 123, true, 123.141241],
-            });
-            expect(coprrecorrect).toEqual(undefined);
-        });
-        it("requires fields with array items and additionalItems with definitions", async () => {
-            const arraySchema = {
-                title: "TITLE",
-                properties: {
-                    arrayOfDefinitions: {
-                        type: "array",
-                        title: "Array of objects",
-                        items: [{ $ref: "#/definitions/commodity" }],
-                        additionalItems: { $ref: "#/definitions/commodity" },
-                    },
-                },
-            };
-            const definitions = {
-                commodity: {
-                    type: "object",
-                    title: "Item",
-                    required: ["commodityId"],
-                    properties: {
-                        commodityId: {
-                            $ref: "#/definitions/selection",
-                        },
-                        insuredValue: {
-                            type: "number",
-                            title: "Insured value in USD",
-                        },
-                    },
-                },
-                selection: {
-                    type: "string",
-                    title: "HS Code",
-                    oneOf: [
-                        { const: "1", title: "One" },
-                        { const: "2", title: "Two" },
-                        { const: "3", title: "Three" },
-                    ],
-                },
-            };
-            const faulty = listErrors(arraySchema, { arrayOfDefinitions: [true, 123, []] }, definitions);
-            expect(faulty).toEqual([
-                "arrayOfDefinitions[0]: must be a `object` type, but the final value was: `true`.",
-                "arrayOfDefinitions[1]: must be a `object` type, but the final value was: `123`.",
-                "arrayOfDefinitions[2]: must be a `object` type, but the final value was: `[]`.",
-            ]);
-            const correct = listErrors(arraySchema, {
-                arrayOfDefinitions: [
-                    { commodityId: "1", insuredValue: 123 },
-                    { commodityId: "2", insuredValue: 456 },
-                    { commodityId: "3", insuredValue: 789 },
-                ],
-            }, definitions);
-            expect(correct).toEqual(undefined);
-        });
-        it("validates anyOf correctly", async () => {
-            const optionalInput = listErrors(anyOfExample(), { warningSymbols: [] });
-            expect(optionalInput).toEqual(undefined);
-            const requiredInput = listErrors(anyOfExample(["warningSymbols"]), {
-                warningSymbols: [],
-            });
-            expect(requiredInput).toEqual(["warningSymbols: Required"]);
-            const requiredInput2 = listErrors(anyOfExample(["warningSymbols"]), {
-                warningSymbols: [6789],
-            });
-            expect(requiredInput2).toEqual(undefined);
-            const wrongInput = listErrors(anyOfExample(), {
-                // false and 1234 are stringified
-                warningSymbols: [false, {}, [], 1234, "invalid value"],
-            });
-            expect(wrongInput).toEqual([
-                "warningSymbols[0]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
-                "warningSymbols[1]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
-                "warningSymbols[2]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
-                "warningSymbols[3]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
-                "warningSymbols[4]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
-            ]);
-            const validInput = listErrors(anyOfExample(), {
-                warningSymbols: ["GHS01", "GHS05", 7890],
-            });
-            expect(validInput).toEqual(undefined);
-        });
-    });
-    describe("Infinite loop validation", () => {
-        const definitions = {
-            Organization: {
-                type: "array",
-                additionalItems: {
-                    type: "object",
-                    properties: {
-                        name: { title: "Name", type: "string" },
-                        subOrganizations: {
-                            $ref: "#/definitions/Organization",
-                        },
-                    },
-                },
-            },
-        };
-        const treeSchema = {
-            title: "Form editor",
-            type: "object",
-            properties: {
-                organization: {
-                    type: "object",
-                    properties: {
-                        name: { title: "Title", type: "string" },
-                        subOrganizations: {
-                            $ref: "#/definitions/Organization",
-                        },
-                    },
-                },
-            },
-        };
-        it("does not throw RangeError: Maximum call stack size exceeded", async () => {
-            const validInput1 = listErrors(treeSchema, {
-                organization: {
-                    name: "Org A",
-                    subOrganizations: [],
-                },
-            }, definitions);
-            expect(validInput1).toEqual(undefined);
-            const validInput2 = listErrors(treeSchema, {
-                organization: {
-                    name: "Org A",
-                    subOrganizations: [
-                        {
-                            name: "Sub A1",
-                            subOrganizations: [
-                                {
-                                    name: "Sub A2",
-                                    subOrganizations: [
-                                        {
-                                            name: "Sub A3",
-                                            subOrganizations: [
-                                                {
-                                                    name: "Sub A4",
-                                                    subOrganizations: [
-                                                        {
-                                                            name: "Sub A5",
-                                                            subOrganizations: [
-                                                                {
-                                                                    name: "Sub A6",
-                                                                    subOrganizations: [
-                                                                        {
-                                                                            name: "Sub A7",
-                                                                            subOrganizations: [
-                                                                                {
-                                                                                    name: "Sub A8",
-                                                                                    subOrganizations: [],
-                                                                                },
-                                                                            ],
-                                                                        },
-                                                                    ],
-                                                                },
-                                                            ],
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                        {
-                            name: "Sub B1",
-                            subOrganizations: [
-                                {
-                                    name: "Sub B2",
-                                    subOrganizations: [],
-                                },
-                            ],
-                        },
-                    ],
-                },
-            }, definitions);
-            expect(validInput2).toEqual(undefined);
-            const invalidInput = listErrors(treeSchema, {
-                organization: {
-                    name: "Org A",
-                    subOrganizations: 123,
-                },
-            }, definitions);
-            expect(invalidInput).toEqual(["organization.subOrganizations: Required"]);
-        });
-    });
-});