@nolwenture/formik-jsonschema-form 0.26.2 → 0.26.4

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

@@ -0,0 +1,946 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ageFieldDefinition_1 = require("../../sampleData/ageFieldDefinition");
+const createValidationSchema_1 = require("../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_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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 = (0, createValidationSchema_1.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"]);
+        });
+    });
+});