@integration-app/react 0.1.1

package/node_modules/@integration-app/sdk/data-builder/locators.test.js

@@ -0,0 +1,775 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const formulas_1 = require("./formulas");
+const locators_1 = require("./locators");
+describe('Data Composer', () => {
+    const PROPERTY_NAME = 'testProperty';
+    const TEST_SIMPLE_SCHEMA = { type: 'string' };
+    const TEST_COMPLEX_SCHEMA = {
+        type: 'object',
+        properties: {
+            [PROPERTY_NAME]: {
+                anyOf: [
+                    {
+                        type: 'array',
+                        key: 'keyValue',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                [PROPERTY_NAME]: {
+                                    type: 'array',
+                                    items: TEST_SIMPLE_SCHEMA,
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    };
+    const OBJECT_PROPERTY_LOCATOR = new locators_1.DataLocatorStepObjectProperty(PROPERTY_NAME);
+    const ARRAY_ITEM_LOCATOR = new locators_1.DataLocatorStepArrayItem(2);
+    const CURRENT_ITEM_LOCATOR = new locators_1.DataLocatorStepCurrentArrayItem();
+    const SCHEMA_OPTION_LOCATOR = new locators_1.DataLocatorStepSchemaOption('keyValue');
+    describe('getSchemaByLocator', () => {
+        it('should return schema by empty locator', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, [])).toEqual(TEST_COMPLEX_SCHEMA);
+        });
+        it('should return schema for object property locator', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, [OBJECT_PROPERTY_LOCATOR])).toEqual(TEST_COMPLEX_SCHEMA.properties[PROPERTY_NAME]);
+        });
+        it('should return schema for any of locator', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, [
+                OBJECT_PROPERTY_LOCATOR,
+                SCHEMA_OPTION_LOCATOR,
+            ])).toEqual(TEST_COMPLEX_SCHEMA.properties[PROPERTY_NAME].anyOf[0]);
+        });
+        it('should return schema for array item locator', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, [
+                OBJECT_PROPERTY_LOCATOR,
+                SCHEMA_OPTION_LOCATOR,
+                ARRAY_ITEM_LOCATOR,
+            ])).toEqual(TEST_COMPLEX_SCHEMA.properties[PROPERTY_NAME].anyOf[0].items);
+        });
+        it('should return schema for current array item locator', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, [
+                OBJECT_PROPERTY_LOCATOR,
+                SCHEMA_OPTION_LOCATOR,
+                ARRAY_ITEM_LOCATOR,
+                OBJECT_PROPERTY_LOCATOR,
+                CURRENT_ITEM_LOCATOR,
+            ])).toEqual(TEST_COMPLEX_SCHEMA.properties[PROPERTY_NAME].anyOf[0].items.properties[PROPERTY_NAME].items);
+        });
+        it('should return null if object property does not exist', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, '$.nonExistentProperty')).toBeNull();
+        });
+        it('should return null if used $current without an array', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, '$.$current')).toBeNull();
+        });
+        it('should return null if used array index not on array', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, `$.${PROPERTY_NAME}[1]`)).toBeNull();
+        });
+        it('should return null if used non-existed any of option', () => {
+            expect((0, locators_1.getSchemaByLocator)(TEST_COMPLEX_SCHEMA, `$.${PROPERTY_NAME}<nonExistingKey>`)).toBeNull();
+        });
+    });
+    describe('setSchemaAtLocator', () => {
+        it('should set schema at root', () => {
+            expect((0, locators_1.setSchemaAtLocator)({ type: 'string' }, '$', TEST_COMPLEX_SCHEMA)).toEqual(TEST_COMPLEX_SCHEMA);
+        });
+        it('should set schema for object key and keep other keys', () => {
+            expect((0, locators_1.setSchemaAtLocator)({ type: 'object', properties: { existingKey: TEST_SIMPLE_SCHEMA } }, '$.key', TEST_COMPLEX_SCHEMA)).toEqual({
+                type: 'object',
+                properties: {
+                    key: TEST_COMPLEX_SCHEMA,
+                    existingKey: TEST_SIMPLE_SCHEMA,
+                },
+            });
+        });
+        it('should set schema for array items but keey existing schema as well', () => {
+            expect((0, locators_1.setSchemaAtLocator)({
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: { existingKey: TEST_SIMPLE_SCHEMA },
+                },
+            }, '$.$current.key', TEST_COMPLEX_SCHEMA)).toEqual({
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        key: TEST_COMPLEX_SCHEMA,
+                        existingKey: TEST_SIMPLE_SCHEMA,
+                    },
+                },
+            });
+        });
+    });
+    describe('makeSchemaForLocator', () => {
+        it('should make schema for empty locator', () => {
+            expect((0, locators_1.makeSchemaForLocator)([], TEST_SIMPLE_SCHEMA)).toEqual(TEST_SIMPLE_SCHEMA);
+        });
+        it('should make schema for object property locator', () => {
+            expect((0, locators_1.makeSchemaForLocator)([OBJECT_PROPERTY_LOCATOR], TEST_SIMPLE_SCHEMA)).toEqual({
+                type: 'object',
+                properties: {
+                    [PROPERTY_NAME]: TEST_SIMPLE_SCHEMA,
+                },
+            });
+        });
+        it('should make schema for array item locator', () => {
+            expect((0, locators_1.makeSchemaForLocator)([ARRAY_ITEM_LOCATOR], TEST_SIMPLE_SCHEMA)).toEqual({
+                type: 'array',
+                items: TEST_SIMPLE_SCHEMA,
+            });
+        });
+        it('should make schema for current item locator', () => {
+            expect((0, locators_1.makeSchemaForLocator)([CURRENT_ITEM_LOCATOR], TEST_SIMPLE_SCHEMA)).toEqual({
+                type: 'array',
+                items: TEST_SIMPLE_SCHEMA,
+            });
+        });
+        it('should make schema for schemaOption locator', () => {
+            const schemaOption = {
+                ...TEST_SIMPLE_SCHEMA,
+                key: SCHEMA_OPTION_LOCATOR.key,
+            };
+            expect((0, locators_1.makeSchemaForLocator)([SCHEMA_OPTION_LOCATOR], schemaOption)).toEqual({
+                anyOf: [
+                    {
+                        ...TEST_SIMPLE_SCHEMA,
+                        key: SCHEMA_OPTION_LOCATOR.key,
+                    },
+                ],
+            });
+        });
+        it('should make schema for a composite locator', () => {
+            expect((0, locators_1.makeSchemaForLocator)([
+                OBJECT_PROPERTY_LOCATOR,
+                SCHEMA_OPTION_LOCATOR,
+                CURRENT_ITEM_LOCATOR,
+                OBJECT_PROPERTY_LOCATOR,
+                ARRAY_ITEM_LOCATOR,
+            ], TEST_SIMPLE_SCHEMA)).toEqual({
+                type: 'object',
+                properties: {
+                    [PROPERTY_NAME]: {
+                        anyOf: [
+                            {
+                                type: 'array',
+                                key: SCHEMA_OPTION_LOCATOR.key,
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        [PROPERTY_NAME]: {
+                                            type: 'array',
+                                            items: TEST_SIMPLE_SCHEMA,
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            });
+        });
+    });
+    describe('locatorToSteps', () => {
+        it('should throw on incorrect value', () => {
+            expect(() => (0, locators_1.locatorToSteps)(null)).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)({ key: 'value' })).toThrow(errors_1.BadRequestError);
+        });
+        it('should throw error for two dots ..', () => {
+            expect(() => (0, locators_1.locatorToSteps)('$..')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('$..')).toThrow('There should be a property name after a dot');
+        });
+        it('should throw error for not closed [ bracket', () => {
+            expect(() => (0, locators_1.locatorToSteps)('$.prop[1')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('$.prop[1')).toThrow('Could not find a closing bracket for the bracket at position 6. Locator: $.prop[1');
+        });
+        it('should throw error for not closed < bracket', () => {
+            expect(() => (0, locators_1.locatorToSteps)('$.prop<1')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('$.prop<1')).toThrow('Could not find a closing bracket for the bracket at position 6. Locator: $.prop<1');
+        });
+        it('should throw error for redundant ] bracket', () => {
+            expect(() => (0, locators_1.locatorToSteps)('$.prop[1]]')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('$.prop[1]]')).toThrow('Unexpected symbol at position 9. Locator: $.prop[1]]');
+        });
+        it('should throw error for redundant > bracket', () => {
+            expect(() => (0, locators_1.locatorToSteps)('$.prop<1>>')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('$.prop<1>>')).toThrow('Unexpected symbol at position 9. Locator: $.prop<1>>');
+        });
+        it('should throw error if [index] is not a number', () => {
+            expect(() => (0, locators_1.locatorToSteps)('$.prop[aa]')).toThrow(errors_1.BadRequestError);
+            expect(() => (0, locators_1.locatorToSteps)('$.prop[aa]')).toThrow('Invalid index [aa]. Index should be a positive numbe');
+        });
+        it('should accept locators without $.', () => {
+            expect((0, locators_1.locatorToSteps)('prop[0]')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('prop'),
+                new locators_1.DataLocatorStepArrayItem(0),
+            ]);
+        });
+        it('should extract locators from simple string locator', () => {
+            expect((0, locators_1.locatorToSteps)('$.name')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('name'),
+            ]);
+        });
+        it('should extract locators from nested object string locator', () => {
+            expect((0, locators_1.locatorToSteps)('$.name.firstName')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('name'),
+                new locators_1.DataLocatorStepObjectProperty('firstName'),
+            ]);
+        });
+        it('should extract locators if root is array', () => {
+            expect((0, locators_1.locatorToSteps)('$[5]')).toEqual([new locators_1.DataLocatorStepArrayItem(5)]);
+        });
+        it('should extract locators from string locator with $current', () => {
+            expect((0, locators_1.locatorToSteps)('$.$current.name')).toEqual([
+                new locators_1.DataLocatorStepCurrentArrayItem(),
+                new locators_1.DataLocatorStepObjectProperty('name'),
+            ]);
+        });
+        it('should extract locators from string locator with array item index: prop[N]', () => {
+            expect((0, locators_1.locatorToSteps)('$.users[52].name')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('users'),
+                new locators_1.DataLocatorStepArrayItem(52),
+                new locators_1.DataLocatorStepObjectProperty('name'),
+            ]);
+        });
+        it('should extract locators from string locator with nested arrays: prop[N][N]', () => {
+            expect((0, locators_1.locatorToSteps)('$.users[52][10].name')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('users'),
+                new locators_1.DataLocatorStepArrayItem(52),
+                new locators_1.DataLocatorStepArrayItem(10),
+                new locators_1.DataLocatorStepObjectProperty('name'),
+            ]);
+        });
+        it('should extract locators from string locator with anyOf', () => {
+            expect((0, locators_1.locatorToSteps)('$.users<key>.name')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('users'),
+                new locators_1.DataLocatorStepSchemaOption('key'),
+                new locators_1.DataLocatorStepObjectProperty('name'),
+            ]);
+        });
+        it('should extract locators from complex string locator', () => {
+            expect((0, locators_1.locatorToSteps)('$.field<key>[0].subfield')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('field'),
+                new locators_1.DataLocatorStepSchemaOption('key'),
+                new locators_1.DataLocatorStepArrayItem(0),
+                new locators_1.DataLocatorStepObjectProperty('subfield'),
+            ]);
+        });
+        it('should extract locators from nested arrays with nested anyOf locator', () => {
+            expect((0, locators_1.locatorToSteps)('$.field<key>[0]<key2>[3].subfield')).toEqual([
+                new locators_1.DataLocatorStepObjectProperty('field'),
+                new locators_1.DataLocatorStepSchemaOption('key'),
+                new locators_1.DataLocatorStepArrayItem(0),
+                new locators_1.DataLocatorStepSchemaOption('key2'),
+                new locators_1.DataLocatorStepArrayItem(3),
+                new locators_1.DataLocatorStepObjectProperty('subfield'),
+            ]);
+        });
+    });
+    describe('setValueAtLocator', () => {
+        const TEST_OBJECT = {
+            name: 'John',
+            lastName: 'Doe',
+            friends: [
+                {
+                    name: 'Jane',
+                    lastName: 'Doe',
+                },
+                {
+                    name: 'Jack',
+                    lastName: 'Doe',
+                },
+            ],
+        };
+        it('should set value to empty object', () => {
+            const result = (0, locators_1.setValueAtLocator)(null, '$.name', 'John');
+            expect(result).toEqual({ name: 'John' });
+        });
+        it('should return the value if locator is empty', () => {
+            expect((0, locators_1.setValueAtLocator)(TEST_OBJECT, '$', 'value')).toEqual('value');
+        });
+        it('should override a simple property', () => {
+            expect((0, locators_1.setValueAtLocator)(TEST_OBJECT, '$.name', 'Sarah')).toEqual({
+                ...TEST_OBJECT,
+                name: 'Sarah',
+            });
+        });
+        it('should delete property if undefined is provided', () => {
+            expect((0, locators_1.setValueAtLocator)({
+                name: 'John',
+                lastName: 'Doe',
+            }, '$.name', undefined)).toEqual({
+                lastName: 'Doe',
+            });
+        });
+        it('should override a property inside an array', () => {
+            expect((0, locators_1.setValueAtLocator)(TEST_OBJECT, '$.friends[1].lastName', 'Brown')).toEqual({
+                ...TEST_OBJECT,
+                friends: [
+                    TEST_OBJECT.friends[0],
+                    {
+                        ...TEST_OBJECT.friends[1],
+                        lastName: 'Brown',
+                    },
+                ],
+            });
+        });
+        it('should set value at index 0 when used with $current', () => {
+            expect((0, locators_1.setValueAtLocator)(TEST_OBJECT, '$.friends.$current.name', 'Sarah')).toEqual({
+                ...TEST_OBJECT,
+                friends: [
+                    {
+                        ...TEST_OBJECT.friends[0],
+                        name: 'Sarah',
+                    },
+                    TEST_OBJECT.friends[1],
+                ],
+            });
+        });
+        it('should create a property if does not exist', () => {
+            expect((0, locators_1.setValueAtLocator)(TEST_OBJECT, '$.email', 'john@doe.com')).toEqual({
+                ...TEST_OBJECT,
+                email: 'john@doe.com',
+            });
+        });
+        it('should create nested arrays and properties if do not exist', () => {
+            expect((0, locators_1.setValueAtLocator)(TEST_OBJECT, '$.enemies[2].emails[0].value', 'john@doe.com')).toEqual({
+                ...TEST_OBJECT,
+                enemies: [
+                    undefined,
+                    undefined,
+                    {
+                        emails: [
+                            {
+                                value: 'john@doe.com',
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+    describe('stepsToLocator', () => {
+        it('should convert undefined, null, and empty array values to a root locator', () => {
+            expect((0, locators_1.stepsToLocator)(undefined)).toEqual('$');
+            expect((0, locators_1.stepsToLocator)(null)).toEqual('$');
+            expect((0, locators_1.stepsToLocator)([])).toEqual('$');
+        });
+        it('should convert steps to corresponding locator parts', () => {
+            expect((0, locators_1.stepsToLocator)([
+                new locators_1.DataLocatorStepObjectProperty('friends'),
+                new locators_1.DataLocatorStepCurrentArrayItem(),
+                new locators_1.DataLocatorStepObjectProperty('names'),
+                new locators_1.DataLocatorStepArrayItem(2),
+                new locators_1.DataLocatorStepSchemaOption('key'),
+                new locators_1.DataLocatorStepObjectProperty('firstName'),
+            ])).toEqual('$.friends.$current.names[2]<key>.firstName');
+        });
+    });
+    describe('locatorToString', () => {
+        it('should keep empty values empty', () => {
+            expect((0, locators_1.locatorToString)(undefined)).toBeUndefined();
+            expect((0, locators_1.locatorToString)(null)).toEqual(null);
+        });
+        it('should keep string values string', () => {
+            expect((0, locators_1.locatorToString)('')).toEqual('');
+            expect((0, locators_1.locatorToString)('$')).toEqual('$');
+            expect((0, locators_1.locatorToString)('$.name')).toEqual('$.name');
+        });
+        it('should convert locator steps to string', () => {
+            expect((0, locators_1.locatorToString)([
+                new locators_1.DataLocatorStepObjectProperty('posts'),
+                new locators_1.DataLocatorStepCurrentArrayItem(),
+            ])).toEqual('$.posts.$current');
+        });
+    });
+    describe('getIconUriForLocator', () => {
+        it('should return the latest uri encountered along locator steps', () => {
+            const schema = {
+                type: 'object',
+                iconUri: 'uri1',
+                properties: {
+                    prop1: {
+                        type: 'object',
+                        iconUri: 'uri2',
+                        properties: {
+                            prop2: { type: 'string' },
+                        },
+                    },
+                },
+            };
+            expect((0, locators_1.getIconUriForLocator)(schema, '$.prop1.prop2')).toEqual('uri2');
+        });
+        it('should return undefined if schema does not have an icon URI', () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    prop1: {
+                        type: 'object',
+                        properties: {
+                            prop2: { type: 'string' },
+                        },
+                    },
+                },
+            };
+            expect((0, locators_1.getIconUriForLocator)(schema, '$.prop1.prop2')).toBeUndefined();
+        });
+        it('should return null for non-existent locator', () => {
+            const schema = {
+                type: 'string',
+            };
+            expect((0, locators_1.getIconUriForLocator)(schema, '$.prop1.prop2')).toBeNull();
+        });
+    });
+    describe('getNameForLocator', () => {
+        it('should return title if present', () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    prop1: {
+                        type: 'string',
+                        title: 'Prop Name',
+                    },
+                },
+            };
+            expect((0, locators_1.getNameForLocator)(schema, '$.prop1')).toEqual('Prop Name');
+        });
+        it('should return key if title is not present', () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    prop1: {
+                        type: 'string',
+                    },
+                },
+            };
+            expect((0, locators_1.getNameForLocator)(schema, '$.prop1')).toEqual('Prop1');
+        });
+        describe('getNameComponentsForLocator', () => {
+            it('should ignore schemas with title set to empty string', () => {
+                const schema = {
+                    type: 'object',
+                    properties: {
+                        ignore: {
+                            type: 'object',
+                            title: '',
+                            properties: {
+                                prop1: {
+                                    title: 'Prop 1',
+                                },
+                            },
+                        },
+                    },
+                };
+                expect((0, locators_1.getNameComponentsForLocator)(schema, '$.ignore.prop1')).toEqual([
+                    'Prop 1',
+                ]);
+            });
+        });
+        it('should return undefined if locator does not exist', () => {
+            const schema = {
+                type: 'object',
+            };
+            expect((0, locators_1.getNameForLocator)(schema, '$.prop1')).toBeNull();
+        });
+    });
+    describe('getValueAtLocator', () => {
+        const variables = {
+            obj: {
+                prop: 'objPropValue',
+            },
+            arr: [
+                {
+                    arrProp: 'aprPropValue',
+                },
+                {
+                    arrProp: 'aprPropValue2',
+                },
+            ],
+        };
+        it('should return original variable with empty locator', () => {
+            expect((0, locators_1.getValueAtLocator)(variables, '$')).toEqual(variables);
+        });
+        it('should return value from object property locator', () => {
+            expect((0, locators_1.getValueAtLocator)(variables, '$.obj.prop')).toEqual(variables.obj.prop);
+        });
+        it('should return value from array item locator', () => {
+            expect((0, locators_1.getValueAtLocator)(variables, '$.arr[1].arrProp')).toEqual(variables.arr[1].arrProp);
+        });
+        it('should return value from currentItem locator', () => {
+            expect((0, locators_1.getValueAtLocator)(variables, '$.arr.$current.arrProp')).toEqual(variables.arr[0].arrProp);
+        });
+        it('should ignore anyOf locator', () => {
+            expect((0, locators_1.getValueAtLocator)(variables, '$.arr<0>.$current<1>.arrProp')).toEqual(variables.arr[0].arrProp);
+        });
+    });
+    describe('isLocatorUserVisible', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                visibleObject: {
+                    type: 'object',
+                    properties: {
+                        visibleProperty: {
+                            type: 'string',
+                        },
+                        invisibleProperty: {
+                            type: 'string',
+                            userVisible: false,
+                        },
+                    },
+                },
+                invisibleObject: {
+                    type: 'object',
+                    userVisible: false,
+                    properties: {
+                        visibleProperty: {
+                            type: 'string',
+                        },
+                        invisibleProperty: {
+                            type: 'string',
+                            userVisible: false,
+                        },
+                    },
+                },
+                visibleProperty: {
+                    type: 'string',
+                },
+                invisibleProperty: {
+                    type: 'string',
+                    userVisible: false,
+                },
+            },
+        };
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$')).toBe(true);
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$.visibleProperty')).toBe(true);
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$.invisibleProperty')).toBe(false);
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$.visibleObject.visibleProperty')).toBe(true);
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$.visibleObject.invisibleProperty')).toBe(false);
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$.invisibleObject.visibleProperty')).toBe(false);
+        expect((0, locators_1.isLocatorUserVisible)(schema, '$.invisibleObject.invisibleProperty')).toBe(false);
+    });
+    describe('getFormulaLocators', () => {
+        it('should return empty list for an empty value', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, null)).toEqual([]);
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, undefined)).toEqual([]);
+        });
+        it('should return empty list for a scalar value', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, 'value')).toEqual([]);
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, 5)).toEqual([]);
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, false)).toEqual([]);
+        });
+        it('should return empty list for an object without $ui', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, { key: 'value' })).toEqual([]);
+        });
+        it('should return root locator', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, { $var: '$.abc' })).toEqual(['$']);
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.ITERATE, {
+                $iterate: { locator: '$.abc' },
+            })).toEqual(['$']);
+        });
+        it('should return locators inside nested objects', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, {
+                obj: {
+                    key1: {
+                        $var: true,
+                    },
+                    key2: {
+                        $var: {
+                            uiConfig: 'value',
+                        },
+                    },
+                },
+                key: {
+                    $var: true,
+                },
+            })).toEqual(['$.obj.key1', '$.obj.key2', '$.key']);
+        });
+        it('should return locators inside nested lists', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, {
+                obj: {
+                    list: [
+                        {
+                            $var: true,
+                        },
+                        {
+                            listKey: {
+                                $var: true,
+                            },
+                        },
+                    ],
+                },
+            })).toEqual(['$.obj.list[0]', '$.obj.list[1].listKey']);
+        });
+        it('should not return locator if $ui is not the only key', () => {
+            expect((0, locators_1.getFormulaLocators)(formulas_1.DataBuilderFormulaType.VAR, {
+                $var: true,
+                anotherKey: true,
+            })).toEqual([]);
+        });
+    });
+    describe('findValueLocator', () => {
+        it('should work correctly with empty data', () => {
+            expect((0, locators_1.findValueLocators)(null, 'value')).toEqual([]);
+            expect((0, locators_1.findValueLocators)(undefined, 'value')).toEqual([]);
+        });
+        it('should find value if it equals data', () => {
+            expect((0, locators_1.findValueLocators)('value', 'value')).toEqual(['$']);
+            expect((0, locators_1.findValueLocators)(5, 5)).toEqual(['$']);
+            expect((0, locators_1.findValueLocators)(false, false)).toEqual(['$']);
+            expect((0, locators_1.findValueLocators)({ key: 'value' }, { key: 'value' })).toEqual([
+                '$',
+            ]);
+        });
+        it('should find value in object', () => {
+            expect((0, locators_1.findValueLocators)({ key: 'value' }, 'value')).toEqual(['$.key']);
+            expect((0, locators_1.findValueLocators)({ key: { subkey: 'value' } }, { subkey: 'value' })).toEqual(['$.key']);
+        });
+        it('sholud find value in array', () => {
+            expect((0, locators_1.findValueLocators)([1, 2, 3], 1)).toEqual(['$[0]']);
+            expect((0, locators_1.findValueLocators)([{ key: 'not value' }, { key: 'value' }, { key: 'value' }], { key: 'value' })).toEqual(['$[1]', '$[2]']);
+        });
+        it('sholud find value in nested object', () => {
+            expect((0, locators_1.findValueLocators)([
+                1,
+                2,
+                {
+                    key: 1,
+                },
+            ], 1)).toEqual(['$[0]', '$[2].key']);
+        });
+    });
+});
+describe('pickFieldsFromValue', () => {
+    const value = {
+        key: 'value',
+        objKey: {
+            subKey: 'subKeyValue',
+        },
+        listKey: [
+            {
+                listSubKey: 'listSubKeyValue',
+            },
+        ],
+    };
+    it('should pick empty list of fields', () => {
+        expect((0, locators_1.pickFieldsFromValue)(value, [])).toBeUndefined();
+    });
+    it('should pick non-existent values correctly', () => {
+        expect((0, locators_1.pickFieldsFromValue)(value, ['$.nonexistent'])).toBeUndefined();
+    });
+    it('should pick values correctly', () => {
+        expect((0, locators_1.pickFieldsFromValue)(value, ['$.key'])).toEqual({ key: 'value' });
+        expect((0, locators_1.pickFieldsFromValue)(value, ['$.objKey.subKey'])).toEqual({
+            objKey: { subKey: 'subKeyValue' },
+        });
+        expect((0, locators_1.pickFieldsFromValue)(value, ['$.listKey[0].listSubKey'])).toEqual({
+            listKey: [{ listSubKey: 'listSubKeyValue' }],
+        });
+    });
+});
+describe('extractFieldLocator', () => {
+    it('should return original locator for locators without formula', () => {
+        expect((0, locators_1.extractFieldLocator)('$')).toEqual('$');
+        expect((0, locators_1.extractFieldLocator)('$.key')).toEqual('$.key');
+        expect((0, locators_1.extractFieldLocator)('$.objKey.subKey')).toEqual('$.objKey.subKey');
+        expect((0, locators_1.extractFieldLocator)('$.listKey[0].listSubKey')).toEqual('$.listKey[0].listSubKey');
+    });
+    it('should return field part of the locator if it encounters formula', () => {
+        expect((0, locators_1.extractFieldLocator)('$.$map.value')).toEqual('$');
+        expect((0, locators_1.extractFieldLocator)('field.$firstName.value')).toEqual('$.field');
+        expect((0, locators_1.extractFieldLocator)('field.$firstName')).toEqual('$.field');
+    });
+});
+describe('getLocatorsFromData', () => {
+    it('should return no locators for empty data', () => {
+        expect((0, locators_1.getLocatorsFromData)(null)).toEqual([]);
+        expect((0, locators_1.getLocatorsFromData)(undefined)).toEqual([]);
+    });
+    it('should return parent locator if data is not an object or array', () => {
+        expect((0, locators_1.getLocatorsFromData)('value', '$')).toEqual(['$']);
+        expect((0, locators_1.getLocatorsFromData)(5, '$')).toEqual(['$']);
+        expect((0, locators_1.getLocatorsFromData)(false, '$')).toEqual(['$']);
+    });
+    it('should return object keys if data is object', () => {
+        expect((0, locators_1.getLocatorsFromData)({ key: 'value', key2: 'value2' }, '$')).toEqual([
+            '$.key',
+            '$.key2',
+        ]);
+    });
+    it('should return array items if data is array', () => {
+        expect((0, locators_1.getLocatorsFromData)([{ key: 'value' }, 0], '$')).toEqual([
+            '$[0].key',
+            '$[1]',
+        ]);
+    });
+});
+describe('getLocatorsFromSchema', () => {
+    it('should return no locators if schema is empty', () => {
+        expect((0, locators_1.getLocatorsFromSchema)(null)).toEqual([]);
+        expect((0, locators_1.getLocatorsFromSchema)(undefined)).toEqual([]);
+        expect((0, locators_1.getLocatorsFromSchema)({})).toEqual([]);
+    });
+    it('should return parent locator for scalar schema', () => {
+        expect((0, locators_1.getLocatorsFromSchema)({ type: 'string' }, '$')).toEqual(['$']);
+        expect((0, locators_1.getLocatorsFromSchema)({ type: 'number' }, '$')).toEqual(['$']);
+        expect((0, locators_1.getLocatorsFromSchema)({ type: 'boolean' }, '$')).toEqual(['$']);
+    });
+    it('should return object keys for object schema', () => {
+        expect((0, locators_1.getLocatorsFromSchema)({
+            type: 'object',
+            properties: {
+                key: { type: 'string' },
+                key2: { type: 'number' },
+            },
+        }, '$')).toEqual(['$.key', '$.key2']);
+    });
+    it('should return first array item for array schema', () => {
+        expect((0, locators_1.getLocatorsFromSchema)({
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    key: { type: 'string' },
+                },
+            },
+        }, '$')).toEqual(['$[0].key']);
+    });
+});
+describe('excludeFieldsFromValue', () => {
+    it('should exclude simple field', () => {
+        expect((0, locators_1.excludeFieldsFromValue)({ key: 'value', key2: 'value2' }, ['key'])).toEqual({
+            key2: 'value2',
+        });
+    });
+    it('should exclude object key', () => {
+        expect((0, locators_1.excludeFieldsFromValue)({
+            key: 'value',
+            objKey: {
+                subKey: 'subKeyValue',
+            },
+        }, ['objKey.subKey'])).toEqual({
+            key: 'value',
+            objKey: {},
+        });
+    });
+    it('should exclude whole array item', () => {
+        expect((0, locators_1.excludeFieldsFromValue)([1, 2], ['$[0]'])).toEqual([2]);
+    });
+    it('should exclude property from array item', () => {
+        expect((0, locators_1.excludeFieldsFromValue)({
+            key: 'value',
+            listKey: [{ listSubKey: 'listSubKeyValue' }],
+        }, ['listKey[0].listSubKey'])).toEqual({
+            key: 'value',
+            listKey: [{}],
+        });
+    });
+});
+//# sourceMappingURL=locators.test.js.map