@reltio/components 1.4.2070 → 1.4.2071

package/RelationEditor/RelationEditor.test.js

@@ -9,1483 +9,1539 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
 };
 import React from 'react';
-import { mount } from 'enzyme';
-import Button from '@mui/material/Button';
-import Typography from '@mui/material/Typography';
-import { ACTIVENESS_ATTR_TYPES, Directions, ErrorSource, Mode, createTemporaryEntity, getEntityType, getInOutRelations, validateConnection } from '@reltio/mdm-sdk';
-import RelationEditor from './RelationEditor';
-import { ConnectionRelationTypeSelector } from '../ConnectionRelationTypeSelector';
-import { ErrorWrapper } from '../ErrorWrapper';
-import { EntitySelector } from '../EntitySelector';
-import { config, config2, relationTypes } from './relations.test-data';
-import { EditModeAttributesList } from '../EditModeAttributesList';
-import { EditModeComplexAttribute } from '../EditModeComplexAttribute';
-import { EmptyStub } from '../EmptyStub';
+import { screen, render, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { AdapterMoment } from '@mui/x-date-pickers/AdapterMoment';
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
+import { Mode, ScreenType, ProfileViewType, typeAheadSearch, ErrorType, ActivityFilter, ErrorSource, ErrorSeverity } from '@reltio/mdm-sdk';
 import { ScrollToElementContext, ScrollType } from '../contexts/ScrollToElementContext';
-import { MdmModuleProvider, useMdmInitialConnection, useMdmInitialConnectionTempEntity, useMdmModifiedEntity, useMdmModifiedEntities, useMdmProfileErrors, useMdmEntityUri } from '../contexts/MdmModuleContext';
-import { useScrollToAttributeError } from '../hooks/useScrollToAttributeError';
-var editing = Mode.Editing;
-jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getEntityType: jest.fn(), createTemporaryEntity: jest.fn(), validateConnection: jest.fn().mockImplementation(jest.requireActual('@reltio/mdm-sdk').validateConnection), getInOutRelations: jest.fn().mockImplementation(jest.requireActual('@reltio/mdm-sdk').getInOutRelations) })); });
-jest.mock('../EditModeAttributesList', function () { return ({
-    EditModeAttributesList: jest.fn()
-}); });
-jest.mock('../EditModeComplexAttribute', function () { return ({
-    EditModeComplexAttribute: jest.fn()
-}); });
-jest.mock('../EntitySelector', function () { return ({
-    EntitySelector: jest.fn()
-}); });
-jest.mock('../contexts/MdmModuleContext', function () { return (__assign(__assign({}, jest.requireActual('../contexts/MdmModuleContext')), { useMdmInitialConnection: jest.fn(), useMdmInitialConnectionTempEntity: jest.fn(), useMdmModifiedEntity: jest.fn(), useMdmModifiedEntities: jest.fn(), useMdmProfileErrors: jest.fn(), useMdmEntityUri: jest.fn() })); });
-jest.mock('../hooks/useScrollToAttributeError', function () { return (__assign(__assign({}, jest.requireActual('../hooks/useScrollToAttributeError')), { useScrollToAttributeError: jest.fn() })); });
-describe('RelationEditor', function () {
-    var scrollToAttributeError = {
-        ref: React.createRef(),
-        errorClassName: 'errorClassName',
-        path: []
-    };
-    var highlightErrorSpy = jest.fn();
-    var scrollIntoRefSpy = jest.fn();
-    var relationUri = 'relations/1';
-    var mdmAction = jest.fn();
-    var mdmActions = {
-        setInitialInfo: jest.fn(function () { return mdmAction(); }),
-        setRelationType: jest.fn(function () { return mdmAction(); }),
-        closeRelationEditor: jest.fn(function () { return mdmAction(); }),
-        entityCreated: jest.fn(function () { return mdmAction(); }),
-        entityDeleted: jest.fn(function () { return mdmAction(); }),
-        setRelationEntity: jest.fn(function () { return mdmAction(); }),
-        errorDeactivated: jest.fn(function () { return mdmAction(); }),
-        errorsSet: jest.fn(function () { return mdmAction(); }),
-        addAttributes: jest.fn(function () { return mdmAction(); }),
-        modifyAttribute: jest.fn(function () { return mdmAction(); }),
-        removeAttribute: jest.fn(function () { return mdmAction(); }),
-        addRelation: jest.fn(function (_id, _connection) { return mdmAction(); }),
-        editRelation: jest.fn(function (_id, _connection) { return mdmAction(); })
-    };
-    var defaultMdmValues = {
-        initialConnection: { connection: { relation: { relationUri: relationUri }, entity: {} } },
-        initialModifiedEntity: null,
-        modifiedEntity: null,
-        uiConfigLayout: [],
-        uiConfigProfile: [],
-        entityUri: 'entities/123abc'
-    };
-    var defaultProps = {
-        connection: { relation: { relationUri: relationUri }, entity: {} },
-        config: { id: 'relationView1', content: { entityTypes: ['Type1'] } },
-        metadata: {
-            relationTypes: []
-        },
-        mode: editing
+import { MdmModuleProvider } from '../contexts/MdmModuleContext';
+import { HiddenAttributesContext } from '../contexts/HiddenAttributesContext';
+import RelationEditor from './RelationEditor';
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { typeAheadSearch: jest.fn() })); });
+var highlightError = jest.fn();
+var scrollIntoRef = jest.fn();
+var mdmAction = jest.fn();
+var mdmActions = {
+    setInitialInfo: jest.fn(function () { return mdmAction(); }),
+    setRelationType: jest.fn(function () { return mdmAction(); }),
+    closeRelationEditor: jest.fn(function () { return mdmAction(); }),
+    entityCreated: jest.fn(function () { return mdmAction(); }),
+    entityDeleted: jest.fn(function () { return mdmAction(); }),
+    setRelationEntity: jest.fn(function () { return mdmAction(); }),
+    errorDeactivated: jest.fn(function () { return mdmAction(); }),
+    errorsSet: jest.fn(function () { return mdmAction(); }),
+    addAttributes: jest.fn(function () { return mdmAction(); }),
+    modifyAttribute: jest.fn(function () { return mdmAction(); }),
+    removeAttribute: jest.fn(function () { return mdmAction(); }),
+    addRelation: jest.fn(function (_id, _connection) { return mdmAction(); }),
+    editRelation: jest.fn(function (_id, _connection) { return mdmAction(); })
+};
+var defaultRelation = {
+    relationUri: 'relations/uri$$Qgs4qfvmR3Daksyb1697627670006',
+    relationType: 'configuration/relationTypes/HasAddress',
+    relationLabel: 'has address',
+    object: {
+        type: 'configuration/relationTypes/HasAddress',
+        attributes: {},
+        uri: 'relations/uri$$Qgs4qfvmR3Daksyb1697627670006'
+    },
+    direction: 'out'
+};
+var defaultEntity = {
+    uri: 'entities/uri$$123',
+    type: 'configuration/entityTypes/HCP',
+    attributes: {}
+};
+var defaultMdmValues = {
+    relations: {},
+    modifiedEntities: {},
+    entity: defaultEntity,
+    dependentLookups: { editors: {}, structure: {}, initedTypeUris: [] },
+    uiConfigLayout: [],
+    uiConfigProfile: [],
+    profileErrors: []
+};
+var defaultProps = {
+    connection: { relation: defaultRelation, entity: {} },
+    config: {
+        id: 'relationView',
+        component: ProfileViewType.Relations,
+        content: {
+            entityTypes: ['configuration/entityTypes/Location'],
+            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+        }
+    },
+    metadata: {
+        entityTypes: [
+            {
+                uri: 'configuration/entityTypes/HCP',
+                label: 'HCP'
+            },
+            {
+                uri: 'configuration/entityTypes/Location',
+                label: 'Address',
+                dataLabelPattern: '{FirstName}',
+                attributes: [
+                    {
+                        uri: 'configuration/entityTypes/Location/attributes/FirstName',
+                        type: 'String',
+                        name: 'FirstName',
+                        label: 'First Name'
+                    },
+                    {
+                        uri: 'configuration/entityTypes/Location/attributes/Address',
+                        type: 'Reference',
+                        name: 'Address',
+                        label: 'Address',
+                        referencedAttributeURIs: []
+                    }
+                ]
+            },
+            {
+                uri: 'configuration/entityTypes/HCA',
+                label: 'HCA'
+            }
+        ],
+        relationTypes: [
+            {
+                uri: 'configuration/relationTypes/HasAddress',
+                label: 'has address',
+                startObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCP',
+                    uri: 'configuration/relationTypes/HasAddress/startObject'
+                },
+                endObject: {
+                    objectTypeURI: 'configuration/entityTypes/Location',
+                    uri: 'configuration/relationTypes/HasAddress/endObject'
+                },
+                attributes: [
+                    {
+                        label: 'ActiveHiddenAttribute',
+                        name: 'Active',
+                        type: 'Boolean',
+                        uri: 'configuration/relationTypes/HasAddress/attributes/Active'
+                    },
+                    {
+                        label: 'Name',
+                        name: 'Name',
+                        type: 'String',
+                        uri: 'configuration/relationTypes/HasAddress/attributes/Name',
+                        required: true
+                    }
+                ]
+            },
+            {
+                uri: 'configuration/relationTypes/InternalHCAtoHCA',
+                label: 'InternalHCAtoHCA affiliation',
+                startObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCA',
+                    uri: 'configuration/relationTypes/InternalHCAtoHCA/startObject'
+                },
+                endObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCA',
+                    uri: 'configuration/relationTypes/InternalHCAtoHCA/endObject'
+                },
+                attributes: [
+                    {
+                        label: 'Title',
+                        name: 'Title',
+                        type: 'String',
+                        uri: 'configuration/relationTypes/InternalHCAtoHCA/attributes/Title'
+                    },
+                    {
+                        label: 'Affiliation Status',
+                        name: 'AffiliationStatus',
+                        type: 'String',
+                        uri: 'configuration/relationTypes/InternalHCAtoHCA/attributes/AffiliationStatus'
+                    }
+                ]
+            }
+        ]
+    },
+    mode: Mode.Editing
+};
+var setUp = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.props, props = _c === void 0 ? defaultProps : _c, _d = _b.mdmValues, mdmValues = _d === void 0 ? defaultMdmValues : _d, _e = _b.error, error = _e === void 0 ? null : _e, _f = _b.hiddenAttributes, hiddenAttributes = _f === void 0 ? {} : _f;
+    var user = userEvent.setup();
+    var Providers = function (_a) {
+        var children = _a.children;
+        return (React.createElement(HiddenAttributesContext.Provider, { value: hiddenAttributes },
+            React.createElement(ScrollToElementContext.Provider, { value: { element: error, highlightError: highlightError, scrollIntoRef: scrollIntoRef, type: ScrollType.Error } },
+                React.createElement(LocalizationProvider, { dateAdapter: AdapterMoment }, children))));
     };
-    var setUp = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.props, props = _c === void 0 ? defaultProps : _c, _d = _b.mdmValues, mdmValues = _d === void 0 ? defaultMdmValues : _d, _e = _b.contextError, contextError = _e === void 0 ? null : _e;
-        useMdmInitialConnection.mockReturnValue(mdmValues.initialConnection);
-        useMdmInitialConnectionTempEntity.mockReturnValue(mdmValues.initialModifiedEntity);
-        useMdmModifiedEntity.mockReturnValue(mdmValues.modifiedEntity);
-        useMdmModifiedEntities.mockReturnValue(mdmValues.modifiedEntities);
-        useMdmProfileErrors.mockReturnValue(mdmValues.profileErrors);
-        useMdmEntityUri.mockReturnValue(mdmValues.entityUri);
-        var Component = function (props) {
-            return (React.createElement(MdmModuleProvider, { actions: mdmActions, values: mdmValues },
-                React.createElement(ScrollToElementContext.Provider, { value: {
-                        element: contextError,
-                        highlightError: highlightErrorSpy,
-                        scrollIntoRef: scrollIntoRefSpy,
-                        type: ScrollType.Error
-                    } },
-                    React.createElement(RelationEditor, __assign({}, props)))));
-        };
-        return mount(React.createElement(Component, __assign({}, props)));
+    var result = render(React.createElement(MdmModuleProvider, { actions: mdmActions, values: mdmValues },
+        React.createElement(RelationEditor, __assign({}, props))), { wrapper: Providers });
+    var rerender = function (_a) {
+        var newProps = _a.props, newMdmValues = _a.mdmValues;
+        return result.rerender(React.createElement(MdmModuleProvider, { actions: mdmActions, values: __assign(__assign({}, mdmValues), newMdmValues) },
+            React.createElement(RelationEditor, __assign({}, props, newProps))));
     };
-    beforeAll(function () {
-        EditModeComplexAttribute.mockImplementation(function (_a) {
-            var children = _a.children;
-            return React.createElement("div", null, children);
-        });
-        EntitySelector.mockImplementation(EmptyStub);
-        EditModeAttributesList.mockImplementation(EmptyStub);
-        useScrollToAttributeError.mockReturnValue(scrollToAttributeError);
+    return __assign(__assign({}, result), { user: user, rerender: rerender });
+};
+describe('relation editor behaviour', function () {
+    beforeEach(function () {
+        typeAheadSearch.mockResolvedValue([]);
     });
     afterEach(function () {
         jest.clearAllMocks();
     });
-    var findEditorTitle = function (component) { return component.find(Typography).filterWhere(function (t) { return t.hasClass('title'); }); };
-    var findApplyButton = function (component) { return component.find(Button).filterWhere(function (b) { return b.text() === 'Apply'; }); };
-    var findCancelButton = function (component) { return component.find(Button).filterWhere(function (b) { return b.text() === 'Cancel'; }); };
-    it('should render main parts', function () {
-        var component = setUp();
-        var editorTitle = findEditorTitle(component);
-        expect(editorTitle.length).toBe(1);
-        expect(editorTitle.text()).toBe('Edit item');
-        expect(component.find(ConnectionRelationTypeSelector).length).toBe(1);
-        var applyButton = findApplyButton(component);
-        var cancelButton = findCancelButton(component);
-        expect(applyButton.length).toBe(1);
-        expect(applyButton.prop('disabled')).toBe(true);
-        expect(cancelButton.length).toBe(1);
-        expect(component.find(EntitySelector).length).toBe(0);
-        expect(component.find(EditModeAttributesList).length).toBe(0);
-    });
-    it('should show Add item label for new connection', function () {
-        var connection = { relation: { relationUri: relationUri, object: { attributes: {} } }, entity: {}, isNew: true };
-        var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection });
-        var props = __assign(__assign({}, defaultProps), { connection: connection });
-        var component = setUp({ mdmValues: mdmValues, props: props });
-        component.update();
-        var editorTitle = findEditorTitle(component);
-        expect(editorTitle.length).toBe(1);
-        expect(editorTitle.text()).toBe('Add new item');
-        expect(component.find(ConnectionRelationTypeSelector).length).toBe(1);
-        var applyButton = findApplyButton(component);
-        var cancelButton = findCancelButton(component);
-        expect(applyButton.length).toBe(1);
-        expect(applyButton.prop('disabled')).toBe(true);
-        expect(cancelButton.length).toBe(1);
-        expect(component.find(EntitySelector).length).toBe(0);
-        expect(component.find(EditModeAttributesList).length).toBe(0);
-    });
-    it('should render EntitySelector and AttributeList if relationType is specified', function () {
-        var connection = {
-            relation: { relationUri: relationUri, relationType: 'configuration/relationTypes/AccountTeam' },
-            entity: {}
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection });
-        var component = setUp({ props: props });
-        expect(component.find(EntitySelector).length).toBe(1);
-        expect(component.find(EditModeAttributesList).length).toBe(1);
-        var errorWrapper = component.find(".".concat(scrollToAttributeError.errorClassName));
-        expect(errorWrapper).toHaveLength(1);
-        expect(errorWrapper.getElement().ref).toBe(scrollToAttributeError.ref);
-    });
-    it('should call getInOutRelations with correctly params if connection.parentEntityUri does not exist', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam',
-                direction: Directions.IN
-            },
-            entity: {}
-        };
-        var config = {
-            id: 'relationView1',
-            content: { entityTypes: ['Type1'] }
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-        setUp({ props: props });
-        expect(getInOutRelations).toHaveBeenCalledWith({
-            content: config.content,
-            direction: Directions.IN,
-            relationType: 'configuration/relationTypes/AccountTeam',
-            mode: editing,
-            metadata: {
-                relationTypes: []
+    it('should render entity selector correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var activityFilter, searchOptions, mdmValues, user, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    typeAheadSearch.mockResolvedValue([
+                        { type: 'configuration/entityTypes/Location', label: 'location entity 1', uri: 'entities/0C32GxR' },
+                        { type: 'configuration/entityTypes/Location', label: 'location entity 2', uri: 'entities/0G49Cnu' }
+                    ]);
+                    activityFilter = ActivityFilter.ACTIVE_ONLY;
+                    searchOptions = { searchByOv: true, ovOnly: true };
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { activityFilter: activityFilter, searchOptions: searchOptions });
+                    user = setUp({ mdmValues: mdmValues }).user;
+                    screen.getByText('Select Address profile');
+                    screen.getByRole('combobox');
+                    return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    options = screen.getAllByRole('option');
+                    expect(options).toHaveLength(2);
+                    expect(options[0]).toHaveTextContent('location entity 1');
+                    expect(options[1]).toHaveTextContent('location entity 2');
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', {
+                        activityFilter: 'active',
+                        globalFilter: '',
+                        max: 20,
+                        searchOptions: 'searchByOv',
+                        sendMasked: false
+                    });
+                    return [2 /*return*/];
             }
         });
-    });
-    it('should call getInOutRelations with correctly params if connection.parentEntityUri exists', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam',
-                direction: Directions.IN
-            },
-            entity: {},
-            parentEntityUri: 'entities/123'
-        };
-        var config = {
-            id: 'relationView1',
-            content: { entityTypes: ['Type1'] },
-            contentSecondLevel: { entityTypes: ['Type2'] }
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-        setUp({ props: props });
-        expect(getInOutRelations).toHaveBeenCalledWith({
-            content: config.contentSecondLevel,
-            direction: Directions.IN,
-            relationType: 'configuration/relationTypes/AccountTeam',
-            mode: editing,
-            metadata: {
-                relationTypes: []
+    }); });
+    it('should render attributes list correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var labels, values;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setUp();
+                    return [4 /*yield*/, screen.findByText('More attributes')];
+                case 1:
+                    _a.sent();
+                    labels = screen.getAllByTestId('reltio-attribute-label');
+                    values = screen.getAllByTestId('reltio-attribute-value');
+                    expect(labels).toHaveLength(4);
+                    expect(values).toHaveLength(4);
+                    expect(labels[0]).toHaveTextContent('Start date');
+                    expect(within(values[0]).getByRole('textbox')).toHaveValue('');
+                    expect(labels[1]).toHaveTextContent('End date');
+                    expect(within(values[1]).getByRole('textbox')).toHaveValue('');
+                    expect(labels[2]).toHaveTextContent('ActiveHiddenAttribute');
+                    expect(within(values[2]).getAllByRole('checkbox')[0]).not.toBeChecked();
+                    expect(within(values[2]).getAllByRole('checkbox')[1]).not.toBeChecked();
+                    expect(labels[3]).toHaveTextContent('Name*');
+                    expect(within(values[3]).getByRole('textbox')).toHaveValue('');
+                    return [2 /*return*/];
             }
         });
-    });
-    it('should set entityTypesUris prop correctly for EntitySelector if contentSecondLevel is missing in config', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam'
-            },
-            entity: {}
-        };
-        var config = {
-            id: 'relationView1',
-            content: { entityTypes: ['Type1'] }
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-        var component = setUp({ props: props });
-        expect(component.find(EntitySelector).prop('entityTypesUris')).toEqual(['Type1']);
-    });
-    it('should set entityTypesUris prop correctly for EntitySelector if parentEntityUri is missing in connection', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam'
-            },
-            entity: {}
-        };
-        var config = {
-            id: 'relationView1',
-            content: { entityTypes: ['Type1'] },
-            contentSecondLevel: { entityTypes: ['Type2'] }
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-        var component = setUp({ props: props });
-        expect(component.find(EntitySelector).prop('entityTypesUris')).toEqual(['Type1']);
-    });
-    it('should set entityTypesUris prop correctly for EntitySelector if contentSecondLevel and parentEntityUri exists', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam'
-            },
-            entity: {},
-            parentEntityUri: 'entities/123'
-        };
-        var config = {
-            id: 'relationView1',
-            content: { entityTypes: ['Type1'] },
-            contentSecondLevel: { entityTypes: ['Type2'] }
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-        var component = setUp({ props: props });
-        expect(component.find(EntitySelector).prop('entityTypesUris')).toEqual(['Type2']);
-    });
-    it('should render ErrorWrapper for EntitySelector and show error', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam'
-            },
-            entity: {}
-        };
-        var profileErrors = [
-            {
-                parentUri: 'relations/11',
-                uri: '',
-                attributeTypeUri: 'configuration/relationTypes/AccountTeam',
-                message: 'Entity is required',
-                deactivated: true,
-                type: 'missedRefEntity'
-            },
-            {
-                parentUri: connection.relation.relationUri,
-                uri: '',
-                attributeTypeUri: 'configuration/relationTypes/AccountTeam',
-                message: 'Entity is required - deactivated',
-                deactivated: true,
-                type: 'missedRefEntity'
-            },
-            {
-                parentUri: connection.relation.relationUri,
-                uri: '',
-                attributeTypeUri: 'configuration/relationTypes/AccountTeam',
-                message: 'Entity is required',
-                type: 'missedRefEntity'
+    }); });
+    it('should render label correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setUp();
+                    return [4 /*yield*/, screen.findByText('Edit item')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
             }
-        ];
-        var mdmValues = __assign(__assign({}, defaultMdmValues), { profileErrors: profileErrors });
-        var props = __assign(__assign({}, defaultProps), { connection: connection });
-        var component = setUp({ props: props, mdmValues: mdmValues });
-        var errorWrapper = component.find(ErrorWrapper);
-        expect(errorWrapper.length).toBe(1);
-        expect(errorWrapper.prop('errorMessage')).toBe(profileErrors[2].message);
-        expect(errorWrapper.find(EntitySelector).length).toBe(1);
-    });
-    it('should set correct outRelationTypes and inRelationTypes for RelationTypeSelector', function () {
-        var connection = { relation: { relationUri: relationUri }, entity: {} };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-        var component = setUp({ props: props });
-        var relationTypeSelector = component.find(ConnectionRelationTypeSelector);
-        expect(relationTypeSelector.length).toBe(1);
-        expect(relationTypeSelector.prop('relation')).toBe(connection.relation);
-        expect(relationTypeSelector.prop('outRelationTypes')).toEqual([relationTypes[0]]);
-        expect(relationTypeSelector.prop('inRelationTypes')).toEqual([relationTypes[1]]);
-    });
-    it('should render default relation type label instead of RelationTypeSelector if there is only one relation type', function () {
-        var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes.slice(0, 1), entityTypes: [] } });
-        var component = setUp({ props: props });
-        expect(component.find(ConnectionRelationTypeSelector).length).toBe(0);
-    });
-    it('should dispatch setRelationType action on RelationTypeSelector change', function () {
-        var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-        var component = setUp({ props: props });
-        var relationTypeSelector = component.find(ConnectionRelationTypeSelector);
-        expect(relationTypeSelector.length).toBe(1);
-        relationTypeSelector.prop('onChange')({ type: relationTypes[1], direction: Directions.IN });
-        expect(mdmActions.setRelationType).toHaveBeenCalledWith(config.id, relationUri, {
-            type: relationTypes[1],
-            direction: Directions.IN
-        });
-    });
-    it('should set correct props for EditModeAttributesList', function () {
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam',
-                object: {
-                    attributes: {
-                        Role: []
-                    }
-                },
-                startDate: 12345,
-                endDate: 678910
-            },
-            entity: {}
-        };
-        var props = __assign(__assign({}, defaultProps), { connection: connection, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-        var component = setUp({ props: props });
-        var attributesList = component.find(EditModeAttributesList);
-        expect(attributesList.length).toBe(1);
-        expect(attributesList.prop('attrTypes')).toEqual(__spreadArray(__spreadArray([], ACTIVENESS_ATTR_TYPES, true), relationTypes[0].attributes, true));
-        expect(attributesList.prop('entity')).toEqual({
-            attributes: {
-                Role: []
-            },
-            startDate: 12345,
-            endDate: 678910
         });
-        expect(attributesList.prop('showEmptyEditors')).toBe(true);
-        expect(attributesList.prop('parentUri')).toBe(relationUri);
-    });
-    it('should get search options without ovOnly', function () {
-        var activityFilter = 'active';
-        var searchOptions = { searchByOv: true, ovOnly: true };
-        var connection = {
-            relation: {
-                relationUri: relationUri,
-                relationType: 'configuration/relationTypes/AccountTeam'
-            },
-            entity: {}
-        };
-        var metadata = { relationTypes: [] };
-        var mdmValues = __assign(__assign({}, defaultMdmValues), { activityFilter: activityFilter, searchOptions: searchOptions });
-        var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: metadata });
-        var component = setUp({ props: props, mdmValues: mdmValues });
-        var entitySelector = component.find(EntitySelector);
-        expect(entitySelector.prop('globalSearchRequestOptions')).toEqual({
-            activityFilter: 'active',
-            searchOptions: 'searchByOv',
-            globalFilter: ''
+    }); });
+    it('should label for new connection correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var connection, props;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    connection = __assign(__assign({}, defaultProps.connection), { isNew: true });
+                    props = __assign(__assign({}, defaultProps), { connection: connection });
+                    setUp({ props: props });
+                    return [4 /*yield*/, screen.findByText('Add new item')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
         });
-    });
-    describe('Apply button behavior', function () {
-        it('should be disables for new connections with added default values', function () {
-            var connection = {
-                relation: {
-                    relationUri: relationUri,
-                    object: {
-                        attributes: {
-                            Simple: [
-                                {
-                                    value: 'simple default'
-                                }
-                            ]
-                        }
-                    }
-                },
-                entity: {},
-                isNew: true
-            };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var component = setUp({ props: props });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
+    }); });
+    it('should render correctly if parentEntityUri and contentSecondLevel exists', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var connection, config, props;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    connection = __assign(__assign({}, defaultProps.connection), { parentEntityUri: 'entities/HsPM72G' });
+                    config = __assign(__assign({}, defaultProps.config), { contentSecondLevel: {
+                            entityTypes: ['configuration/entityTypes/HCA'],
+                            outRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
+                    setUp({ props: props });
+                    return [4 /*yield*/, screen.findByText('Select HCA profile')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
         });
-        it('should call addRelation action on Apply button click for new connections', function () {
-            var connection = {
-                relation: { relationUri: relationUri, object: { attributes: {} } },
-                entity: {},
-                isNew: true
-            };
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection });
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            component.setProps({
-                connection: {
-                    __metadata: {
-                        draft: 'added'
-                    },
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: '123',
-                        object: {
-                            type: '123'
-                        }
-                    },
-                    entity: {
-                        entityUri: 'entities/456'
-                    },
-                    isNew: true,
-                    initial: {
-                        connection: {
-                            __metadata: {
-                                draft: 'added'
-                            },
-                            relation: {
-                                relationUri: relationUri,
-                                relationType: '123',
-                                object: {
-                                    type: '123'
-                                }
-                            },
-                            entity: {
-                                entityUri: 'entities/456'
-                            },
-                            isNew: true
-                        }
-                    }
-                }
-            });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            var clearedConnection = {
-                relation: {
-                    relationUri: relationUri,
-                    relationType: '123',
-                    object: {
-                        type: '123'
-                    }
-                },
-                entity: {
-                    entityUri: 'entities/456'
-                },
-                initial: {
-                    connection: {
-                        __metadata: {
-                            draft: 'added'
+    }); });
+    it('should show error for entity selector correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var profileErrors, mdmValues, errorMessage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    profileErrors = [
+                        {
+                            parentUri: 'relations/11',
+                            uri: '',
+                            attributeTypeUri: defaultRelation.relationType,
+                            message: 'Entity is required',
+                            deactivated: true,
+                            type: ErrorType.missedRefEntity
                         },
-                        entity: {
-                            entityUri: 'entities/456'
+                        {
+                            parentUri: defaultRelation.relationUri,
+                            uri: '',
+                            attributeTypeUri: defaultRelation.relationType,
+                            message: 'Entity is required - deactivated',
+                            deactivated: true,
+                            type: ErrorType.missedRefEntity
                         },
-                        isNew: true,
-                        relation: {
-                            object: {
-                                type: '123'
-                            },
-                            relationType: '123',
-                            relationUri: 'relations/1'
+                        {
+                            parentUri: defaultRelation.relationUri,
+                            uri: '',
+                            attributeTypeUri: defaultRelation.relationType,
+                            message: 'Entity is required',
+                            type: ErrorType.missedRefEntity
                         }
-                    }
-                },
-                isNew: true
-            };
-            expect(mdmActions.addRelation).toHaveBeenCalledWith(config.id, clearedConnection);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, clearedConnection.relation.relationUri);
+                    ];
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { profileErrors: profileErrors });
+                    setUp({ mdmValues: mdmValues });
+                    return [4 /*yield*/, screen.findByTestId('error-message')];
+                case 1:
+                    errorMessage = _a.sent();
+                    expect(errorMessage).toHaveTextContent('Entity is required');
+                    return [2 /*return*/];
+            }
         });
-        it('should not call addRelation action on Apply button if connection has validation errors', function () {
-            var relationUri = 'relations/uri$$123';
-            var connection = {
-                relation: { relationUri: relationUri, object: { attributes: {} } },
-                entity: {},
-                isNew: true
-            };
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection });
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config2, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            var addedConnection = {
-                __metadata: {
-                    draft: 'added'
-                },
-                relation: {
-                    relationUri: relationUri,
-                    relationType: 'configuration/relationTypes/HCPtoHCA',
-                    object: {
-                        attributes: {
-                            Role: [
-                                {
-                                    ov: true,
-                                    type: 'configuration/relationTypes/HCPtoHCA/attributes/Role',
-                                    uri: 'relations/uri$$123/attributes/Role/uri$$abc',
-                                    value: ''
-                                }
-                            ]
-                        },
-                        type: 'configuration/relationTypes/HCPtoHCA',
-                        uri: relationUri
-                    }
-                },
-                entity: {
-                    entityUri: 'entities/456'
-                },
-                isNew: true
-            };
-            component.setProps({
-                connection: addedConnection
-            });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([
-                {
-                    attributeType: {
-                        label: 'Role',
-                        name: 'Role',
-                        type: 'String',
-                        hidden: false,
-                        important: false,
-                        system: false,
-                        required: true,
-                        attributeOrdering: {
-                            orderType: 'ASC',
-                            orderingStrategy: 'LUD'
-                        },
-                        uri: 'configuration/relationTypes/HCPtoHCA/attributes/Role'
-                    },
-                    attributeTypeUri: 'configuration/relationTypes/HCPtoHCA/attributes/Role',
-                    message: 'Attribute is required',
-                    parentUri: relationUri,
-                    type: 'missed',
-                    uri: '',
-                    source: ErrorSource.local,
-                    path: [
+    }); });
+    it('should render relation type selector correctly if it is not possible to evaluate default relation type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, props, user, relationTypeSelector, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: ['configuration/entityTypes/Location'],
+                            inRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { config: config });
+                    user = setUp({ props: props }).user;
+                    relationTypeSelector = screen.getByTestId('relation-type-selector');
+                    within(relationTypeSelector).getByText('Select relationship type');
+                    within(relationTypeSelector).getByText('has address');
+                    within(relationTypeSelector).getByRole('combobox');
+                    return [4 /*yield*/, user.click(within(relationTypeSelector).getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    options = screen.getAllByRole('option');
+                    expect(options).toHaveLength(2);
+                    expect(options[0]).toHaveTextContent('InternalHCAtoHCA affiliation');
+                    expect(options[1]).toHaveTextContent('has address');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should dispatch setRelationType action on relation type selector change', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, props, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: ['configuration/entityTypes/Location'],
+                            inRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { config: config });
+                    user = setUp({ props: props }).user;
+                    return [4 /*yield*/, user.click(within(screen.getByTestId('relation-type-selector')).getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, user.click(screen.getByText('InternalHCAtoHCA affiliation'))];
+                case 2:
+                    _a.sent();
+                    expect(mdmActions.setRelationType).toHaveBeenCalledWith(props.config.id, expect.any(String), {
+                        direction: 'in',
+                        type: __assign(__assign({}, defaultProps.metadata.relationTypes[1]), { endObject: __assign(__assign({}, defaultProps.metadata.relationTypes[1].endObject), { objectType: { label: 'HCA', uri: 'configuration/entityTypes/HCA' } }), startObject: __assign(__assign({}, defaultProps.metadata.relationTypes[1].startObject), { objectType: { label: 'HCA', uri: 'configuration/entityTypes/HCA' } }) })
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should show "create entity" button if mode is not suggesting', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var user, inputs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    user = setUp().user;
+                    inputs = screen.getAllByRole('combobox');
+                    return [4 /*yield*/, user.click(inputs[0])];
+                case 1:
+                    _a.sent();
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', {
+                        globalFilter: '',
+                        max: 20,
+                        searchOptions: '',
+                        sendMasked: false
+                    });
+                    screen.getByText('Create new Address');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should show "create entity" button if mode is suggesting, but main entity uri is not temporary', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var props, mdmValues, user, inputs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    props = __assign(__assign({}, defaultProps), { mode: Mode.Suggesting });
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { entity: __assign(__assign({}, defaultEntity), { uri: 'entities/123' }) });
+                    user = setUp({ props: props, mdmValues: mdmValues }).user;
+                    inputs = screen.getAllByRole('combobox');
+                    return [4 /*yield*/, user.click(inputs[0])];
+                case 1:
+                    _a.sent();
+                    screen.getByText('Create new Address');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should show "create entity" button if mode is suggesting, main entity uri is temporary, but authoring mode is enabled for current entity type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var uiConfigProfile, props, mdmValues, user, inputs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    uiConfigProfile = [
                         {
-                            label: '<No label>, Affiliated with',
-                            type: 'relationConnection',
-                            value: addedConnection,
-                            valueType: relationTypes[2],
-                            viewId: 'relationView2'
+                            label: 'Profile',
+                            id: 'com.reltio.plugins.ProfileEntityAction',
+                            class: ScreenType.Profile,
+                            entityTypes: {
+                                'configuration/entityTypes/HCP': {
+                                    views: [],
+                                    layout: [],
+                                    sidePanelViews: [],
+                                    authoring: [{ label: 'Profile details', views: [], layout: [] }]
+                                }
+                            }
                         }
-                    ]
-                }
-            ]);
-            expect(mdmActions.addRelation).not.toHaveBeenCalledWith(config.id, expect.any(Object));
-            expect(mdmActions.closeRelationEditor).not.toHaveBeenCalledWith(config.id, expect.any(String));
+                    ];
+                    props = __assign(__assign({}, defaultProps), { mode: Mode.Suggesting });
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { uiConfigProfile: uiConfigProfile });
+                    user = setUp({ props: props, mdmValues: mdmValues }).user;
+                    inputs = screen.getAllByRole('combobox');
+                    return [4 /*yield*/, user.click(inputs[0])];
+                case 1:
+                    _a.sent();
+                    screen.getByText('Create new Address');
+                    return [2 /*return*/];
+            }
         });
-        it('should call editRelation action on Apply button click for existing connections', function () {
-            var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var component = setUp({ props: props });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            component.setProps({
-                connection: {
-                    __metadata: {
-                        draft: 'edited'
-                    },
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: '123',
-                        object: {
-                            type: '123'
-                        }
-                    },
-                    entity: {
-                        entityUri: 'entities/456'
-                    }
-                }
-            });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            var clearedConnection = {
-                relation: {
-                    relationUri: relationUri,
-                    relationType: '123',
-                    object: {
-                        type: '123'
-                    }
-                },
-                entity: {
-                    entityUri: 'entities/456'
-                }
-            };
-            expect(mdmActions.editRelation).toHaveBeenCalledWith(config.id, clearedConnection);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, clearedConnection.relation.relationUri);
+    }); });
+    it('should not show "create entity" button if mode is "Suggesting", main entity uri is temporary and authoring mode is not enabled for current entity type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var props, user, inputs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    props = __assign(__assign({}, defaultProps), { mode: Mode.Suggesting });
+                    user = setUp({ props: props }).user;
+                    inputs = screen.getAllByRole('combobox');
+                    return [4 /*yield*/, user.click(inputs[0])];
+                case 1:
+                    _a.sent();
+                    expect(screen.queryByText('Create new Address')).not.toBeInTheDocument();
+                    return [2 /*return*/];
+            }
         });
-        it('should not call editRelation action on Apply button click if connection has validation errors', function () {
-            var props = __assign(__assign({}, defaultProps), { config: config2, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var component = setUp({ props: props });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            var editedConnection = {
-                __metadata: {
-                    draft: 'edited'
-                },
-                relation: {
-                    relationUri: relationUri,
-                    relationType: 'configuration/relationTypes/HCPtoHCA',
-                    object: {
-                        attributes: {
-                            Role: [
-                                {
-                                    ov: true,
-                                    type: 'configuration/relationTypes/HCPtoHCA/attributes/Role',
-                                    uri: 'relations/uri$$123/attributes/Role/uri$$abc',
-                                    value: ''
+    }); });
+    it('should not hide hidden attributes', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var hiddenAttributes, user, inputs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    hiddenAttributes = { 'entities/uri$$123': ['configuration/relationTypes/HasAddress/attributes/Active'] };
+                    user = setUp({ hiddenAttributes: hiddenAttributes }).user;
+                    inputs = screen.getAllByRole('combobox');
+                    return [4 /*yield*/, user.click(inputs[0])];
+                case 1:
+                    _a.sent();
+                    expect(screen.getByText('ActiveHiddenAttribute')).toBeInTheDocument();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should add sendMasked option if connection entity has attribute with masked value', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var props, user, inputs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    props = __assign(__assign({}, defaultProps), { connection: {
+                            relation: defaultRelation,
+                            entity: {
+                                uri: 'entities/uri$$123',
+                                type: 'configuration/entityTypes/HCP',
+                                object: {
+                                    uri: 'entities/04B1CqH',
+                                    type: 'configuration/entityTypes/Location',
+                                    attributes: {
+                                        Address: [
+                                            {
+                                                label: 'AcOEvPaVqTfzZCE Josogaf VA',
+                                                relationshipLabel: '',
+                                                value: {
+                                                    AddressLine1: [
+                                                        {
+                                                            type: 'configuration/entityTypes/Location/attributes/AddressLine1',
+                                                            ov: true,
+                                                            value: 'AcOEvPaVqTfzZCE',
+                                                            uri: 'entities/04B1CqH/attributes/Address/03R51aT/AddressLine1/1XFBcmPYm'
+                                                        }
+                                                    ],
+                                                    AddressLine2: [
+                                                        {
+                                                            type: 'configuration/entityTypes/Location/attributes/AddressLine2',
+                                                            ov: true,
+                                                            masked: true,
+                                                            value: 'KBmiSMlqhElLHMH',
+                                                            uri: 'entities/04B1CqH/attributes/Address/03R51aT/AddressLine2/1XFBcmTp2'
+                                                        }
+                                                    ]
+                                                }
+                                            }
+                                        ]
+                                    }
                                 }
-                            ]
-                        },
-                        type: 'configuration/relationTypes/HCPtoHCA',
-                        uri: relationUri
-                    }
-                },
-                entity: {
-                    entityUri: 'entities/456'
-                }
-            };
-            component.setProps({
-                connection: editedConnection
-            });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([
-                {
-                    attributeType: {
-                        label: 'Role',
-                        name: 'Role',
-                        type: 'String',
-                        hidden: false,
-                        important: false,
-                        system: false,
-                        required: true,
-                        attributeOrdering: {
-                            orderType: 'ASC',
-                            orderingStrategy: 'LUD'
-                        },
-                        uri: 'configuration/relationTypes/HCPtoHCA/attributes/Role'
-                    },
-                    attributeTypeUri: 'configuration/relationTypes/HCPtoHCA/attributes/Role',
-                    message: 'Attribute is required',
-                    parentUri: relationUri,
-                    type: 'missed',
-                    uri: '',
-                    source: ErrorSource.local,
-                    path: [
+                            }
+                        } });
+                    user = setUp({ props: props }).user;
+                    inputs = screen.getAllByRole('textbox');
+                    return [4 /*yield*/, user.click(inputs[0])];
+                case 1:
+                    _a.sent();
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', {
+                        globalFilter: '',
+                        max: 20,
+                        searchOptions: '',
+                        sendMasked: true
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    describe('apply button', function () {
+        var createRelation = function (value) { return (__assign(__assign({}, defaultProps.connection.relation), { object: __assign(__assign({}, defaultProps.connection.relation.object), { attributes: {
+                    Name: [
                         {
-                            label: '<No label>, Affiliated with',
-                            type: 'relationConnection',
-                            value: editedConnection,
-                            valueType: relationTypes[2],
-                            viewId: 'relationView2'
+                            uri: 'relations/uri$$Qgs4qfvmR3Daksyb1697627670006/attributes/Name/uri$$jIo2A6VSD',
+                            type: 'configuration/relationTypes/HasAddress/attributes/Name',
+                            value: value
                         }
                     ]
-                }
-            ]);
-            expect(mdmActions.editRelation).not.toHaveBeenCalledWith(config.id, expect.any(Object));
-            expect(mdmActions.closeRelationEditor).not.toHaveBeenCalledWith(config.id, expect.any(String));
-        });
-        it('should evaluate and update connection entity label if modified entity is specified', function () {
-            getEntityType.mockReturnValue({ dataLabelPattern: '{Name}' });
-            var expectedLabel = 'new Label!';
-            var modifiedEntity = {
-                uri: 'entities/uri$$1',
-                attributes: { Name: [{ value: expectedLabel, uri: '123' }] }
-            };
-            var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialModifiedEntity: modifiedEntity, modifiedEntity: modifiedEntity });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            component.setProps({
-                connection: {
-                    __metadata: {
-                        draft: 'edited'
-                    },
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: '123',
-                        object: {
-                            type: '123'
-                        }
-                    },
-                    entity: {
-                        entityUri: 'entities/uri$$1',
-                        entityType: 'type',
-                        entityLabel: '',
-                        object: {
-                            uri: 'entities/uri$$1',
-                            type: 'type',
-                            label: ''
-                        }
-                    }
+                } }) })); };
+        var createEntity = function (uri) { return ({
+            entityUri: uri,
+            entityType: 'configuration/entityTypes/Location',
+            entityLabel: 'location entity',
+            object: { uri: uri, type: 'configuration/entityTypes/Location', label: 'location entity' }
+        }); };
+        it('should be disables for new connections with added default values', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var connection, props, applyButton;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        connection = { relation: createRelation('name value'), entity: {}, isNew: true };
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        setUp({ props: props });
+                        return [4 /*yield*/, screen.findByText('Apply')];
+                    case 1:
+                        applyButton = _a.sent();
+                        expect(applyButton).toBeDisabled();
+                        return [2 /*return*/];
                 }
             });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            var expectedConnection = {
-                relation: {
-                    relationUri: relationUri,
-                    relationType: '123',
-                    object: {
-                        type: '123'
-                    }
-                },
-                entity: {
-                    entityUri: 'entities/uri$$1',
-                    entityType: 'type',
-                    entityLabel: expectedLabel,
-                    object: {
-                        uri: 'entities/uri$$1',
-                        type: 'type',
-                        label: expectedLabel
-                    }
+        }); });
+        it('should call addRelation action on Apply button click for new connections', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entity, relation, connection, props, user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entity = createEntity('entities/0C32GxR');
+                        relation = createRelation('new name value');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, isNew: true });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        user = setUp({ props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Apply'))];
+                    case 1:
+                        _a.sent();
+                        expect(mdmActions.addRelation).toHaveBeenCalledWith(props.config.id, connection);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, relation.relationUri);
+                        return [2 /*return*/];
                 }
-            };
-            expect(mdmActions.editRelation).toHaveBeenCalledWith(config.id, expectedConnection);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, expectedConnection.relation.relationUri);
-        });
-        it('should not update connection entity label if modified entity is not specified', function () {
-            getEntityType.mockReturnValue({ dataLabelPattern: '{Name}' });
-            var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes, entityTypes: [] } });
-            var component = setUp({ props: props });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            component.setProps({
-                connection: {
-                    __metadata: {
-                        draft: 'edited'
-                    },
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: '123',
-                        object: {
-                            type: '123'
-                        }
-                    },
-                    entity: {
-                        entityUri: 'entities/uri$$1',
-                        entityType: 'type',
-                        entityLabel: '',
-                        object: {
-                            uri: 'entities/uri$$1',
-                            type: 'type',
-                            label: ''
-                        }
-                    }
+            });
+        }); });
+        it('should not call addRelation action on Apply button if connection has validation errors', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entity, relation, connection, props, user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entity = createEntity('entities/0C32GxR');
+                        relation = createRelation('');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, isNew: true });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        user = setUp({ props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Apply'))];
+                    case 1:
+                        _a.sent();
+                        expect(mdmActions.addRelation).not.toHaveBeenCalled();
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([
+                            {
+                                attributeType: props.metadata.relationTypes[0].attributes[1],
+                                attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/Name',
+                                message: 'Attribute is required',
+                                parentUri: connection.relation.relationUri,
+                                path: [
+                                    {
+                                        label: 'location entity, has address',
+                                        type: 'relationConnection',
+                                        value: connection,
+                                        valueType: props.metadata.relationTypes[0],
+                                        viewId: props.config.id
+                                    }
+                                ],
+                                source: ErrorSource.local,
+                                type: ErrorType.missed,
+                                uri: ''
+                            }
+                        ]);
+                        expect(mdmActions.closeRelationEditor).not.toHaveBeenCalled();
+                        return [2 /*return*/];
                 }
             });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            var expectedConnection = {
-                relation: {
-                    relationUri: relationUri,
-                    relationType: '123',
-                    object: {
-                        type: '123'
-                    }
-                },
-                entity: {
-                    entityUri: 'entities/uri$$1',
-                    entityType: 'type',
-                    entityLabel: '',
-                    object: {
-                        uri: 'entities/uri$$1',
-                        type: 'type',
-                        label: ''
-                    }
+        }); });
+        it('should call editRelation action on Apply button click for existing connections', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entity, relation, connection, props, user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entity = createEntity('entities/0C32GxR');
+                        relation = createRelation('new name value');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        user = setUp({ props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Apply'))];
+                    case 1:
+                        _a.sent();
+                        expect(mdmActions.editRelation).toHaveBeenCalledWith(props.config.id, connection);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, relation.relationUri);
+                        return [2 /*return*/];
                 }
-            };
-            expect(mdmActions.editRelation).toHaveBeenCalledWith(config.id, expectedConnection);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, expectedConnection.relation.relationUri);
-        });
-        it('should clean up outdated temp modified entities', function () {
-            getEntityType.mockReturnValue({});
-            var connection = {
-                relation: { relationUri: relationUri },
-                entity: { entityUri: 'entities/uri$$relationEntity' }
-            };
-            var initialAllModifiedEntities = {
-                'entities/uri$$relationEntity': {
-                    uri: 'entities/uri$$relationEntity',
-                    attributes: {
-                        Address: [
+            });
+        }); });
+        it('should not call editRelation action on Apply button click if connection has validation errors', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entity, relation, connection, props, user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entity = createEntity('entities/0C32GxR');
+                        relation = createRelation('');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        user = setUp({ props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Apply'))];
+                    case 1:
+                        _a.sent();
+                        expect(mdmActions.editRelation).not.toHaveBeenCalled();
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([
                             {
-                                refEntity: [
+                                attributeType: props.metadata.relationTypes[0].attributes[1],
+                                attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/Name',
+                                message: 'Attribute is required',
+                                parentUri: connection.relation.relationUri,
+                                path: [
                                     {
-                                        objectURI: 'entities/uri$$addressEntity1'
+                                        label: 'location entity, has address',
+                                        type: 'relationConnection',
+                                        value: connection,
+                                        valueType: props.metadata.relationTypes[0],
+                                        viewId: props.config.id
                                     }
-                                ]
-                            },
-                            {
-                                refEntity: [
+                                ],
+                                source: ErrorSource.local,
+                                type: ErrorType.missed,
+                                uri: ''
+                            }
+                        ]);
+                        expect(mdmActions.closeRelationEditor).not.toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should evaluate and update connection entity label if modified entity is specified', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, entity, relation, connection, modifiedEntity, props, mdmValues, user;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        entity = createEntity(entityUri);
+                        relation = createRelation('new name value');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity });
+                        modifiedEntity = {
+                            type: 'configuration/entityTypes/Location',
+                            uri: entityUri,
+                            attributes: {
+                                FirstName: [
                                     {
-                                        objectURI: 'entities/uri$$addressEntity2'
+                                        uri: 'entities/uri$$kAp2KJM8/attributes/FirstName/uri$$wsbN3s0X',
+                                        type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                        value: 'first name value'
                                     }
                                 ]
                             }
-                        ]
-                    }
-                },
-                'entities/uri$$addressEntity1': {
-                    uri: 'entities/uri$$addressEntity1',
-                    attributes: {
-                        Location: [
-                            {
-                                refEntity: [
+                        };
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntities: (_a = {}, _a[entityUri] = modifiedEntity, _a) });
+                        user = setUp({ mdmValues: mdmValues, props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Apply'))];
+                    case 1:
+                        _b.sent();
+                        expect(mdmActions.editRelation).toHaveBeenCalledWith(props.config.id, {
+                            entity: __assign(__assign({}, entity), { entityLabel: 'first name value', object: __assign(__assign({}, entity.object), { label: 'first name value' }) }),
+                            relation: relation
+                        });
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, relation.relationUri);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should clean up outdated temp modified entities', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, entity, relation, connection, modifiedEntities, props, mdmValues, _a, user, rerender, updatedModifiedEntities, updatedEntity, updatedConnection;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        entity = createEntity(entityUri);
+                        relation = createRelation('new name value');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity });
+                        modifiedEntities = (_b = {},
+                            _b[entityUri] = {
+                                type: 'configuration/entityTypes/Location',
+                                uri: entityUri,
+                                attributes: {
+                                    Address: [
+                                        {
+                                            refEntity: [{ objectURI: 'entities/uri$$kLnBs782' }],
+                                            refRelation: null,
+                                            uri: 'entities/uri$$kAp2KJM8/attributes/Address/uri$$nbsAsD',
+                                            value: {},
+                                            relationshipLabel: '',
+                                            startObjectCrosswalks: []
+                                        },
+                                        {
+                                            refEntity: [{ objectURI: 'entities/uri$$bAWp0mnS' }],
+                                            refRelation: null,
+                                            uri: 'entities/uri$$kAp2KJM8/attributes/Address/uri$$nSplKs321',
+                                            value: {},
+                                            relationshipLabel: '',
+                                            startObjectCrosswalks: []
+                                        }
+                                    ]
+                                }
+                            },
+                            _b['entities/uri$$kLnBs782'] = {
+                                type: 'configuration/entityTypes/Location',
+                                uri: 'entities/uri$$kLnBs782',
+                                attributes: {
+                                    Address: [
+                                        {
+                                            refEntity: [
+                                                {
+                                                    objectURI: 'entities/uri$$ks0PsMA'
+                                                }
+                                            ],
+                                            refRelation: null,
+                                            uri: 'entities/uri$$kLnBs782/attributes/Address/uri$$o23NbsDA',
+                                            value: {},
+                                            relationshipLabel: '',
+                                            startObjectCrosswalks: []
+                                        }
+                                    ]
+                                }
+                            },
+                            _b['entities/uri$$bAWp0mnS'] = {
+                                uri: 'entities/uri$$bAWp0mnS',
+                                type: 'configuration/entityTypes/HCP'
+                            },
+                            _b['entities/uri$$ks0PsMA'] = {
+                                uri: 'entities/uri$$ks0PsMA',
+                                type: 'configuration/entityTypes/HCP'
+                            },
+                            _b['entities/uri$$MsS01sDA'] = {
+                                uri: 'entities/uri$$MsS01sDA',
+                                type: 'configuration/entityTypes/HCP'
+                            },
+                            _b);
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntities: modifiedEntities });
+                        _a = setUp({ mdmValues: mdmValues, props: props }), user = _a.user, rerender = _a.rerender;
+                        updatedModifiedEntities = __assign(__assign({}, modifiedEntities), { 'entities/uri$$jSdsAA32': {
+                                uri: 'entities/uri$$jSdsAA32',
+                                type: 'configuration/entityTypes/Location',
+                                attributes: {}
+                            } });
+                        updatedEntity = createEntity('entities/uri$$jSdsAA32');
+                        updatedConnection = __assign(__assign({}, connection), { entity: updatedEntity });
+                        rerender({
+                            mdmValues: __assign(__assign({}, mdmValues), { modifiedEntities: updatedModifiedEntities }),
+                            props: __assign(__assign({}, props), { connection: updatedConnection })
+                        });
+                        return [4 /*yield*/, user.click(screen.getByText('Apply'))];
+                    case 1:
+                        _c.sent();
+                        expect(mdmActions.editRelation).toHaveBeenCalledWith(props.config.id, __assign(__assign({}, connection), { entity: __assign(__assign({}, updatedEntity), { entityLabel: '', object: __assign(__assign({}, updatedEntity.object), { label: '' }) }) }));
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, relation.relationUri);
+                        expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$kLnBs782');
+                        expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$bAWp0mnS');
+                        expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$ks0PsMA');
+                        expect(mdmActions.entityDeleted).not.toHaveBeenCalledWith('entities/uri$$MsS01sDA');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should disable apply button if modified entity and connection was not changed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, entity, relation, modifiedEntity, connection, mdmConnection, props, mdmValues, applyButton;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        entity = createEntity(entityUri);
+                        relation = createRelation('name value');
+                        modifiedEntity = {
+                            type: 'configuration/entityTypes/Location',
+                            uri: entityUri,
+                            attributes: {
+                                FirstName: [
                                     {
-                                        objectURI: 'entities/uri$$locationEntity'
+                                        uri: 'entities/uri$$kAp2KJM8/attributes/FirstName/uri$$wsbN3s0X',
+                                        type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                        value: 'first name value'
                                     }
                                 ]
                             }
-                        ]
-                    }
-                },
-                'entities/uri$$addressEntity2': {
-                    uri: 'entities/uri$$addressEntity2'
-                },
-                'entities/uri$$locationEntity': {
-                    uri: 'entities/uri$$locationEntity'
-                },
-                'entities/uri$$notRelatedEntity': {
-                    uri: 'entities/uri$$notRelatedEntity'
+                        };
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, isNew: true });
+                        mdmConnection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, initial: { modifiedEntity: modifiedEntity, connection: connection } });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {}, _a[props.config.id] = { relationsToEdit: [mdmConnection] }, _a), modifiedEntities: (_b = {}, _b[entityUri] = modifiedEntity, _b) });
+                        setUp({ props: props, mdmValues: mdmValues });
+                        return [4 /*yield*/, screen.findByText('Apply')];
+                    case 1:
+                        applyButton = _c.sent();
+                        expect(applyButton).toBeDisabled();
+                        return [2 /*return*/];
                 }
-            };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: { relationTypes: relationTypes, entityTypes: [{ uri: '456', attributes: [] }] } });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection, modifiedEntity: initialAllModifiedEntities['entities/uri$$relationEntity'], initialModifiedEntity: initialAllModifiedEntities['entities/uri$$relationEntity'], modifiedEntities: initialAllModifiedEntities });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            useMdmModifiedEntity.mockReturnValue({
-                uri: 'entities/uri$$newRelationEntity',
-                attributes: {}
             });
-            useMdmModifiedEntities.mockReturnValue(__assign(__assign({}, initialAllModifiedEntities), { 'entities/uri$$newRelationEntity': {
-                    uri: 'entities/uri$$newRelationEntity',
-                    type: '456'
-                } }));
-            // set new connection entity, so referenced Address and Location entities from old connection entity becomes outdated
-            component.setProps({
-                connection: {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: '123',
-                        object: {
-                            type: '123'
-                        }
-                    },
-                    entity: { entityUri: 'entities/uri$$newRelationEntity' }
+        }); });
+        it('should enable apply button if modified entity was changed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var createModifiedEntity, entityUri, entity, relation, connection, mdmConnection, props, mdmValues, applyButton;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        createModifiedEntity = function (value) { return ({
+                            type: 'configuration/entityTypes/Location',
+                            uri: entityUri,
+                            attributes: {
+                                FirstName: [
+                                    {
+                                        uri: 'entities/uri$$kAp2KJM8/attributes/FirstName/uri$$wsbN3s0X',
+                                        type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                        value: value
+                                    }
+                                ]
+                            }
+                        }); };
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        entity = createEntity(entityUri);
+                        relation = createRelation('name value');
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, isNew: true });
+                        mdmConnection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, initial: { modifiedEntity: createModifiedEntity('initial first name'), connection: connection } });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {}, _a[props.config.id] = { relationsToEdit: [mdmConnection] }, _a), modifiedEntities: (_b = {}, _b[entityUri] = createModifiedEntity('changed first name'), _b) });
+                        setUp({ props: props, mdmValues: mdmValues });
+                        return [4 /*yield*/, screen.findByText('Apply')];
+                    case 1:
+                        applyButton = _c.sent();
+                        expect(applyButton).not.toBeDisabled();
+                        return [2 /*return*/];
                 }
             });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            var clearedConnection = {
-                relation: {
-                    relationUri: relationUri,
-                    relationType: '123',
-                    object: {
-                        type: '123'
-                    }
-                },
-                entity: { entityUri: 'entities/uri$$newRelationEntity' }
-            };
-            expect(mdmActions.editRelation).toHaveBeenCalledWith(config.id, clearedConnection);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, clearedConnection.relation.relationUri);
-            expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$addressEntity1');
-            expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$addressEntity2');
-            expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$locationEntity');
-            expect(mdmActions.entityDeleted).not.toHaveBeenCalledWith('entities/uri$$notRelatedEntity');
-        });
-        it('should call validateConnection with correct params', function () {
-            getEntityType.mockReturnValue({});
-            var connection = {
-                relation: { relationUri: relationUri },
-                entity: { entityUri: 'entities/uri$$relationEntity' }
-            };
-            var initialAllModifiedEntities = {};
-            var metadata = { relationTypes: relationTypes, entityTypes: [{ uri: '456', attributes: [] }] };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: metadata });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection, initialModifiedEntity: undefined, modifiedEntity: initialAllModifiedEntities['entities/uri$$relationEntity'], modifiedEntities: initialAllModifiedEntities });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            var updatedAllModifiedEntities = __assign(__assign({}, initialAllModifiedEntities), { 'entities/uri$$newRelationEntity': {
-                    uri: 'entities/uri$$newRelationEntity',
-                    type: '456'
-                } });
-            var updatedConnecton = {
-                relation: {
-                    relationUri: relationUri,
-                    relationType: '123',
-                    object: {
-                        type: '123'
-                    }
-                },
-                entity: { entityUri: 'entities/uri$$newRelationEntity' }
-            };
-            useMdmModifiedEntities.mockReturnValue(updatedAllModifiedEntities);
-            component.setProps({ connection: updatedConnecton });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-            applyButton.find('button').simulate('click');
-            expect(validateConnection).toHaveBeenCalledWith(metadata, updatedAllModifiedEntities, updatedConnecton);
-        });
-        it('should enable Apply button if modified entity was changed', function () {
-            var connection = { relation: { relationUri: relationUri }, entity: { entityUri: 'entities/uri$$123' } };
-            var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes, entityTypes: [] }, connection: connection });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            useMdmModifiedEntity.mockReturnValue({
-                uri: 'entities/$$uri',
-                attributes: []
-            });
-            component.setProps({ test: 1 });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-        });
-        it('should enable Apply button if some referenced entity related to modified entity was changed', function () {
-            var connection = {
-                relation: { relationUri: relationUri },
-                entity: { entityUri: 'entities/uri$$relationEntity' }
-            };
-            var initialAllModifiedEntities = {
-                'entities/uri$$relationEntity': {
-                    uri: 'entities/uri$$relationEntity',
-                    attributes: {
-                        Address: [
-                            {
-                                refEntity: [
+        }); });
+        it('should enable apply button if connection was changed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, entity, relation, modifiedEntity, connection, mdmConnection, props, mdmValues, applyButton;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        entity = createEntity(entityUri);
+                        relation = createRelation('name value');
+                        modifiedEntity = {
+                            type: 'configuration/entityTypes/Location',
+                            uri: entityUri,
+                            attributes: {
+                                FirstName: [
                                     {
-                                        objectURI: 'entities/uri$$addressEntity1'
+                                        uri: 'entities/uri$$kAp2KJM8/attributes/FirstName/uri$$wsbN3s0X',
+                                        type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                        value: 'first name value'
                                     }
                                 ]
                             }
-                        ]
-                    }
-                },
-                'entities/uri$$addressEntity1': {
-                    uri: 'entities/uri$$addressEntity1',
-                    attributes: {
-                        Location: [
-                            {
-                                refEntity: [
+                        };
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, isNew: true });
+                        mdmConnection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, initial: { modifiedEntity: modifiedEntity, connection: __assign(__assign({}, connection), { relation: createRelation('changed name value') }) } });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {}, _a[props.config.id] = { relationsToEdit: [mdmConnection] }, _a), modifiedEntities: (_b = {}, _b[entityUri] = modifiedEntity, _b) });
+                        setUp({ props: props, mdmValues: mdmValues });
+                        return [4 /*yield*/, screen.findByText('Apply')];
+                    case 1:
+                        applyButton = _c.sent();
+                        expect(applyButton).not.toBeDisabled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should enable apply button if some referenced entity related to modified entity was changed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, entity, relation, modifiedEntity, modifiedEntities, connection, mdmConnection, props, mdmValues, rerender, updatedModifiedEntities, applyButton;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        entity = createEntity(entityUri);
+                        relation = createRelation('name value');
+                        modifiedEntity = {
+                            type: 'configuration/entityTypes/Location',
+                            uri: entityUri,
+                            attributes: {
+                                Address: [
                                     {
-                                        objectURI: 'entities/uri$$locationEntity'
+                                        refEntity: [{ objectURI: 'entities/uri$$kLnBs782' }],
+                                        refRelation: null,
+                                        uri: 'entities/uri$$kAp2KJM8/attributes/Address/uri$$nbsAsD',
+                                        value: {},
+                                        relationshipLabel: '',
+                                        startObjectCrosswalks: []
                                     }
                                 ]
                             }
-                        ]
-                    }
-                },
-                'entities/uri$$locationEntity': {
-                    uri: 'entities/uri$$locationEntity'
+                        };
+                        modifiedEntities = (_a = {},
+                            _a[entityUri] = modifiedEntity,
+                            _a['entities/uri$$kLnBs782'] = {
+                                uri: 'entities/uri$$MsS01sDA',
+                                type: 'configuration/entityTypes/Location',
+                                attributes: {
+                                    FirstName: [
+                                        {
+                                            uri: 'entities/uri$$MsS01sDA/attributes/FirstName/uri$$jsNs01HO',
+                                            type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                            value: 'initial first name value'
+                                        }
+                                    ]
+                                }
+                            },
+                            _a);
+                        connection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, isNew: true });
+                        mdmConnection = __assign(__assign({}, defaultProps.connection), { relation: relation, entity: entity, initial: { modifiedEntity: modifiedEntity, connection: connection } });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_b = {}, _b[props.config.id] = { relationsToEdit: [mdmConnection] }, _b), modifiedEntities: modifiedEntities });
+                        rerender = setUp({ props: props, mdmValues: mdmValues }).rerender;
+                        updatedModifiedEntities = __assign(__assign({}, modifiedEntities), { 'entities/uri$$kLnBs782': {
+                                uri: 'entities/uri$$MsS01sDA',
+                                type: 'configuration/entityTypes/Location',
+                                attributes: {
+                                    FirstName: [
+                                        {
+                                            uri: 'entities/uri$$MsS01sDA/attributes/FirstName/uri$$jsNs01HO',
+                                            type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                            value: 'changed first name value'
+                                        }
+                                    ]
+                                }
+                            } });
+                        rerender({ mdmValues: __assign(__assign({}, mdmValues), { modifiedEntities: updatedModifiedEntities }) });
+                        return [4 /*yield*/, screen.findByText('Apply')];
+                    case 1:
+                        applyButton = _c.sent();
+                        expect(applyButton).not.toBeDisabled();
+                        return [2 /*return*/];
                 }
-            };
-            var props = __assign(__assign({}, defaultProps), { config: config, metadata: { relationTypes: relationTypes, entityTypes: [] }, connection: connection });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialConnection: connection, modifiedEntity: initialAllModifiedEntities['entities/uri$$relationEntity'], initialModifiedEntity: initialAllModifiedEntities['entities/uri$$relationEntity'], modifiedEntities: initialAllModifiedEntities });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            var applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(true);
-            // change deep referenced entity (modifiedEntity is not changed)
-            useMdmModifiedEntities.mockReturnValue(__assign(__assign({}, initialAllModifiedEntities), { 'entities/uri$$locationEntity': {
-                    uri: 'entities/uri$$locationEntity',
-                    attributes: {}
-                } }));
-            component.setProps({ test: 1 });
-            applyButton = findApplyButton(component);
-            expect(applyButton.prop('disabled')).toBe(false);
-        });
+            });
+        }); });
     });
-    describe('Cancel button behavior', function () {
-        it('should call closeRelationEditor action and remove related errors', function () {
-            var modifiedEntity = null;
-            var connection = { relation: { relationUri: relationUri }, entity: {} };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-            var profileErrors = [
-                {
-                    parentUri: 'relations/2',
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/AccountTeam',
-                    message: 'Entity is required',
-                    deactivated: true,
-                    type: 'missed'
-                },
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/BusinessCode',
-                    message: 'Entity is required',
-                    type: 'missed'
-                },
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/AddressType',
-                    message: 'Entity is required',
-                    type: 'missed'
-                }
-            ];
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntity: modifiedEntity, initialModifiedEntity: modifiedEntity, profileErrors: profileErrors });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            findCancelButton(component).find('button').simulate('click');
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([
-                {
-                    parentUri: 'relations/2',
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/AccountTeam',
-                    message: 'Entity is required',
-                    deactivated: true,
-                    type: 'missed'
-                }
-            ]);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, connection.relation.relationUri);
-            expect(mdmAction).toHaveBeenCalledTimes(2);
-        });
-        it('should delete modified entity if there was no entity initially but it was set after', function () {
-            var connection = { relation: { relationUri: relationUri }, entity: { entityUri: 'entities/uri$$123' } };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-            var profileErrors = [
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/BusinessCode',
-                    message: 'Entity is required',
-                    type: 'missed'
+    describe('cancel button', function () {
+        it('should call closeRelationEditor action and remove related errors', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var profileErrors, mdmValues, user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        profileErrors = [
+                            {
+                                parentUri: 'relations/11',
+                                uri: '',
+                                attributeTypeUri: defaultRelation.relationType,
+                                message: 'Entity is required',
+                                deactivated: true,
+                                type: ErrorType.missedRefEntity
+                            },
+                            {
+                                parentUri: defaultRelation.relationUri,
+                                uri: '',
+                                attributeTypeUri: defaultRelation.relationType,
+                                message: 'Entity is required - deactivated',
+                                deactivated: true,
+                                type: ErrorType.missedRefEntity
+                            },
+                            {
+                                parentUri: defaultRelation.relationUri,
+                                uri: '',
+                                attributeTypeUri: defaultRelation.relationType,
+                                message: 'Entity is required',
+                                type: ErrorType.missedRefEntity
+                            }
+                        ];
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { profileErrors: profileErrors });
+                        user = setUp({ mdmValues: mdmValues }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Cancel'))];
+                    case 1:
+                        _a.sent();
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([
+                            {
+                                attributeTypeUri: defaultRelation.relationType,
+                                deactivated: true,
+                                message: 'Entity is required',
+                                parentUri: 'relations/11',
+                                type: ErrorType.missedRefEntity,
+                                uri: ''
+                            }
+                        ]);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri);
+                        expect(mdmAction).toHaveBeenCalledTimes(2);
+                        return [2 /*return*/];
                 }
-            ];
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { profileErrors: profileErrors });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            useMdmModifiedEntity.mockReturnValue({
-                uri: 'entities/uri$$123',
-                attributes: []
             });
-            component.setProps({ test: 1 });
-            findCancelButton(component).find('button').simulate('click');
-            expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$123');
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, connection.relation.relationUri);
-            expect(mdmAction).toHaveBeenCalledTimes(3);
-        });
-        it('should restore modified entity to initial state if there was initial entity and it was changed/cleared', function () {
-            var connection = { relation: { relationUri: relationUri }, entity: {} };
-            var initialModifiedEntity = {
-                uri: 'entities/uri$$initial',
-                attributes: []
-            };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-            var profileErrors = [
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/BusinessCode',
-                    message: 'Entity is required',
-                    type: 'missed'
-                }
-            ];
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialModifiedEntity: initialModifiedEntity, modifiedEntity: initialModifiedEntity, profileErrors: profileErrors });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            useMdmModifiedEntity.mockReturnValue({
-                uri: 'entities/uri$$initial',
-                attributes: {
-                    Name: [{ value: '123', uri: 'uri' }]
+        }); });
+        it('should delete modified entity if there was no entity initially but it was set after', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, connection, modifiedEntity, props, mdmValues, user;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        connection = __assign(__assign({}, defaultProps.connection), { entity: {
+                                entityUri: entityUri,
+                                entityType: 'configuration/entityTypes/Location',
+                                entityLabel: 'location entity',
+                                object: { uri: entityUri, type: 'configuration/entityTypes/Location', label: 'location entity' }
+                            } });
+                        modifiedEntity = { type: 'configuration/entityTypes/Location', uri: entityUri, attributes: {} };
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {},
+                                _a[props.config.id] = {
+                                    relationsToEdit: [__assign(__assign({}, defaultProps.connection), { initial: { connection: connection } })]
+                                },
+                                _a), modifiedEntities: (_b = {},
+                                _b[entityUri] = modifiedEntity,
+                                _b) });
+                        user = setUp({ props: props, mdmValues: mdmValues }).user;
+                        mdmAction.mockClear();
+                        return [4 /*yield*/, user.click(screen.getByText('Cancel'))];
+                    case 1:
+                        _c.sent();
+                        expect(mdmActions.entityDeleted).toHaveBeenCalledWith(entityUri);
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, connection.relation.relationUri);
+                        expect(mdmAction).toHaveBeenCalledTimes(3);
+                        return [2 /*return*/];
                 }
             });
-            component.setProps({ test: 1 });
-            findCancelButton(component).find('button').simulate('click');
-            expect(mdmActions.entityCreated).toHaveBeenCalledWith(initialModifiedEntity);
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, connection.relation.relationUri);
-            expect(mdmAction).toHaveBeenCalledTimes(3);
-        });
-        it('should restore initial modified entity if it was changed to another one (and delete new one)', function () {
-            var connection = { relation: { relationUri: relationUri }, entity: { entityUri: 'entities/uri$$initial' } };
-            var initialModifiedEntity = {
-                uri: 'entities/uri$$initial',
-                attributes: []
-            };
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-            var profileErrors = [
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/BusinessCode',
-                    message: 'Entity is required',
-                    type: 'missed'
-                }
-            ];
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialModifiedEntity: initialModifiedEntity, modifiedEntity: initialModifiedEntity, profileErrors: profileErrors });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            useMdmModifiedEntity.mockReturnValue({
-                uri: 'entities/uri$$newone',
-                attributes: {
-                    Name: [{ value: '123', uri: 'uri' }]
+        }); });
+        it('should restore modified entity to initial state if there was initial entity and it was changed/cleared', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, modifiedEntity, relationToEdit, mdmValues, user;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        modifiedEntity = { type: 'configuration/entityTypes/Location', uri: entityUri, attributes: {} };
+                        relationToEdit = __assign(__assign({}, defaultProps.connection), { initial: { connection: defaultProps.connection, modifiedEntity: modifiedEntity } });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {}, _a[defaultProps.config.id] = { relationsToEdit: [relationToEdit] }, _a), modifiedEntities: {} });
+                        user = setUp({ mdmValues: mdmValues }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Cancel'))];
+                    case 1:
+                        _b.sent();
+                        expect(mdmActions.entityCreated).toHaveBeenCalledWith(modifiedEntity);
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri);
+                        expect(mdmAction).toHaveBeenCalledTimes(3);
+                        return [2 /*return*/];
                 }
             });
-            component.setProps({
-                connection: { relation: { relationUri: relationUri }, entity: { entityUri: 'entities/uri$$newone' } }
+        }); });
+        it('should restore initial modified entity if it was changed to another one (and delete new one)', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, modifiedEntity, connection, relationToEdit, mdmValues, props, user;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        modifiedEntity = { type: 'configuration/entityTypes/Location', uri: entityUri, attributes: {} };
+                        connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: 'entities/uri$$7BhsS31L' } });
+                        relationToEdit = __assign(__assign({}, connection), { initial: { connection: defaultProps.connection, modifiedEntity: modifiedEntity } });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {}, _a[defaultProps.config.id] = { relationsToEdit: [relationToEdit] }, _a), modifiedEntities: { 'entities/uri$$7BhsS31L': __assign(__assign({}, modifiedEntity), { uri: 'entities/uri$$7BhsS31L' }) } });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        user = setUp({ mdmValues: mdmValues, props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Cancel'))];
+                    case 1:
+                        _b.sent();
+                        expect(mdmActions.entityCreated).toHaveBeenCalledWith(modifiedEntity);
+                        expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$7BhsS31L');
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, connection.relation.relationUri);
+                        expect(mdmAction).toHaveBeenCalledTimes(4);
+                        return [2 /*return*/];
+                }
             });
-            findCancelButton(component).find('button').simulate('click');
-            expect(mdmActions.entityCreated).toHaveBeenCalledWith(initialModifiedEntity);
-            expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$newone');
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, connection.relation.relationUri);
-            expect(mdmAction).toHaveBeenCalledTimes(4);
-        });
-        it('should not call additional actions if modifiedEntity prop was not changed', function () {
-            var connection = { relation: { relationUri: relationUri }, entity: { entityUri: 'entities/uri$$123' } };
-            var modifiedEntity = {
-                uri: 'entities/uri$$123',
-                attributes: []
-            };
-            var profileErrors = [
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/BusinessCode',
-                    message: 'Entity is required',
-                    type: 'missed'
+        }); });
+        it('should not call additional actions if modifiedEntity prop was not changed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, modifiedEntity, connection, relationToEdit, mdmValues, props, user;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        modifiedEntity = { type: 'configuration/entityTypes/Location', uri: entityUri, attributes: {} };
+                        connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: entityUri } });
+                        relationToEdit = __assign(__assign({}, connection), { initial: { connection: defaultProps.connection, modifiedEntity: modifiedEntity } });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_a = {}, _a[defaultProps.config.id] = { relationsToEdit: [relationToEdit] }, _a), modifiedEntities: (_b = {}, _b[entityUri] = modifiedEntity, _b) });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        user = setUp({ mdmValues: mdmValues, props: props }).user;
+                        return [4 /*yield*/, user.click(screen.getByText('Cancel'))];
+                    case 1:
+                        _c.sent();
+                        expect(mdmActions.entityCreated).not.toHaveBeenCalled();
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, connection.relation.relationUri);
+                        expect(mdmAction).toHaveBeenCalledTimes(2);
+                        return [2 /*return*/];
                 }
-            ];
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialModifiedEntity: modifiedEntity, modifiedEntity: modifiedEntity, profileErrors: profileErrors });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            component.setProps({
-                connection: {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: '123'
-                    },
-                    entity: {
-                        entityUri: 'entities/uri$$123'
-                    }
+            });
+        }); });
+        it('should restore all related referenced entities to their initial state and delete outdated related referenced entities', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entityUri, connection, modifiedEntities, relationToEdit, mdmValues, props, _a, user, rerender, updatedModifiedEntities;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        entityUri = 'entities/uri$$kAp2KJM8';
+                        connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: entityUri } });
+                        modifiedEntities = (_b = {},
+                            _b[entityUri] = {
+                                type: 'configuration/entityTypes/Location',
+                                uri: entityUri,
+                                attributes: {
+                                    Address: [
+                                        {
+                                            refEntity: [{ objectURI: 'entities/uri$$kLnBs782' }],
+                                            refRelation: null,
+                                            uri: 'entities/uri$$kAp2KJM8/attributes/Address/uri$$nbsAsD',
+                                            value: {},
+                                            relationshipLabel: '',
+                                            startObjectCrosswalks: []
+                                        }
+                                    ]
+                                }
+                            },
+                            _b['entities/uri$$kLnBs782'] = {
+                                type: 'configuration/entityTypes/Location',
+                                uri: 'entities/uri$$kLnBs782',
+                                attributes: {
+                                    Address: [
+                                        {
+                                            refEntity: [
+                                                {
+                                                    objectURI: 'entities/uri$$ks0PsMA'
+                                                }
+                                            ],
+                                            refRelation: null,
+                                            uri: 'entities/uri$$kLnBs782/attributes/Address/uri$$o23NbsDA',
+                                            value: {},
+                                            relationshipLabel: '',
+                                            startObjectCrosswalks: []
+                                        }
+                                    ]
+                                }
+                            },
+                            _b['entities/uri$$ks0PsMA'] = {
+                                uri: 'entities/uri$$ks0PsMA',
+                                type: 'configuration/entityTypes/Location'
+                            },
+                            _b);
+                        relationToEdit = __assign(__assign({}, connection), { initial: { connection: defaultProps.connection, modifiedEntity: modifiedEntities[entityUri] } });
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { relations: (_c = {}, _c[defaultProps.config.id] = { relationsToEdit: [relationToEdit] }, _c), modifiedEntities: modifiedEntities });
+                        props = __assign(__assign({}, defaultProps), { connection: connection });
+                        _a = setUp({ mdmValues: mdmValues, props: props }), user = _a.user, rerender = _a.rerender;
+                        updatedModifiedEntities = __assign(__assign({}, modifiedEntities), { 'entities/uri$$ks0PsMA': {
+                                type: 'configuration/entityTypes/Location',
+                                uri: 'entities/uri$$ks0PsMA',
+                                attributes: {
+                                    Address: [
+                                        {
+                                            refEntity: [
+                                                {
+                                                    objectURI: 'entities/uri$$8jKsBssA3'
+                                                }
+                                            ],
+                                            refRelation: null,
+                                            uri: 'entities/uri$$ks0PsMA/attributes/Address/uri$$o23NbsDA',
+                                            value: {},
+                                            relationshipLabel: '',
+                                            startObjectCrosswalks: []
+                                        }
+                                    ]
+                                }
+                            }, 'entities/uri$$8jKsBssA3': {
+                                uri: 'entities/uri$$8jKsBssA3',
+                                type: 'configuration/entityTypes/Location'
+                            }, 'entities/uri$$IS2bSa92': {
+                                uri: 'entities/uri$$IS2bSa92',
+                                type: 'configuration/entityTypes/HCP'
+                            } });
+                        rerender({ mdmValues: __assign(__assign({}, mdmValues), { modifiedEntities: updatedModifiedEntities }) });
+                        return [4 /*yield*/, user.click(screen.getByText('Cancel'))];
+                    case 1:
+                        _d.sent();
+                        expect(mdmActions.entityCreated).toHaveBeenCalledWith(modifiedEntities['entities/uri$$kLnBs782']);
+                        expect(mdmActions.entityCreated).toHaveBeenCalledWith(modifiedEntities['entities/uri$$ks0PsMA']);
+                        expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$8jKsBssA3');
+                        expect(mdmActions.entityDeleted).not.toHaveBeenCalledWith('entities/uri$$IS2bSa92');
+                        expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
+                        expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(props.config.id, connection.relation.relationUri);
+                        expect(mdmAction).toHaveBeenCalledTimes(5);
+                        return [2 /*return*/];
                 }
             });
-            findCancelButton(component).find('button').simulate('click');
-            expect(mdmActions.entityCreated).not.toHaveBeenCalledWith(modifiedEntity);
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, connection.relation.relationUri);
-            expect(mdmAction).toHaveBeenCalledTimes(2);
-        });
-        it('should restore all related referenced entities to their initial state and delete outdated related referenced entities', function () {
-            var connection = { relation: { relationUri: relationUri }, entity: { entityUri: 'entities/uri$$relationEntity' } };
-            var initialAllModifiedEntities = {
-                'entities/uri$$relationEntity': {
-                    uri: 'entities/uri$$relationEntity',
-                    attributes: {
-                        Address: [
-                            {
-                                refEntity: [
-                                    {
-                                        objectURI: 'entities/uri$$addressEntity1'
-                                    }
-                                ]
-                            }
-                        ]
+        }); });
+    });
+    describe('entity selector', function () {
+        describe('creating', function () {
+            it('should create new entity and call events for saving it in relation and in modified entities store slice', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var user;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            user = setUp().user;
+                            return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, user.click(screen.getByText('Create new Address'))];
+                        case 2:
+                            _a.sent();
+                            expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri, {
+                                attributes: {},
+                                timestamp: expect.any(Number),
+                                type: 'configuration/entityTypes/Location',
+                                uri: expect.any(String)
+                            });
+                            expect(mdmActions.entityCreated).toHaveBeenCalledWith({
+                                attributes: {},
+                                timestamp: expect.any(Number),
+                                type: 'configuration/entityTypes/Location',
+                                uri: expect.any(String)
+                            });
+                            expect(mdmAction).toHaveBeenCalledTimes(2);
+                            return [2 /*return*/];
                     }
-                },
-                'entities/uri$$addressEntity1': {
-                    uri: 'entities/uri$$addressEntity1',
-                    attributes: {
-                        Location: [
-                            {
-                                refEntity: [
-                                    {
-                                        objectURI: 'entities/uri$$locationEntity'
-                                    }
-                                ]
-                            }
-                        ]
+                });
+            }); });
+            it('should delete previous temp (modified) entity before creating new one', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var entityUri, modifiedEntity, connection, mdmValues, props, user;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            entityUri = 'entities/uri$$kAp2KJM8';
+                            modifiedEntity = { type: 'configuration/entityTypes/Location', uri: entityUri, attributes: {} };
+                            connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: entityUri, entityType: 'configuration/entityTypes/Location' } });
+                            mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntities: (_a = {}, _a[entityUri] = modifiedEntity, _a) });
+                            props = __assign(__assign({}, defaultProps), { connection: connection });
+                            user = setUp({ mdmValues: mdmValues, props: props }).user;
+                            return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                        case 1:
+                            _b.sent();
+                            return [4 /*yield*/, user.click(screen.getByText('Create new Address'))];
+                        case 2:
+                            _b.sent();
+                            expect(mdmActions.setInitialInfo).toHaveBeenCalledWith(props.config.id, props.connection.relation.relationUri, modifiedEntity);
+                            expect(mdmActions.entityDeleted).toHaveBeenCalledWith(entityUri);
+                            expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri, {
+                                attributes: {},
+                                timestamp: expect.any(Number),
+                                type: 'configuration/entityTypes/Location',
+                                uri: expect.any(String)
+                            });
+                            expect(mdmActions.entityCreated).toHaveBeenCalledWith({
+                                attributes: {},
+                                timestamp: expect.any(Number),
+                                type: 'configuration/entityTypes/Location',
+                                uri: expect.any(String)
+                            });
+                            expect(mdmAction).toHaveBeenCalledTimes(4);
+                            return [2 /*return*/];
                     }
-                },
-                'entities/uri$$locationEntity': {
-                    uri: 'entities/uri$$locationEntity'
-                }
-            };
-            var initialModifiedEntity = initialAllModifiedEntities['entities/uri$$relationEntity'];
-            var profileErrors = [
-                {
-                    parentUri: connection.relation.relationUri,
-                    uri: '',
-                    attributeTypeUri: 'configuration/relationTypes/HasAddress/attributes/BusinessCode',
-                    message: 'Entity is required',
-                    type: 'missed'
-                }
-            ];
-            var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-            var mdmValues = __assign(__assign({}, defaultMdmValues), { initialModifiedEntity: initialModifiedEntity, modifiedEntity: initialModifiedEntity, modifiedEntities: initialAllModifiedEntities, profileErrors: profileErrors });
-            var component = setUp({ props: props, mdmValues: mdmValues });
-            useMdmModifiedEntities.mockReturnValue(__assign(__assign({}, initialAllModifiedEntities), { 'entities/uri$$locationEntity': {
-                    uri: 'entities/uri$$locationEntity',
-                    attributes: {
-                        Ref: [
-                            {
-                                refEntity: [
-                                    {
-                                        objectURI: 'entities/uri$$outdatedEntity'
-                                    }
-                                ]
-                            }
-                        ]
+                });
+            }); });
+            it('should create new entity with init value and call events when onCreate prop was called with initValue argument', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var user;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            user = setUp().user;
+                            return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, user.type(screen.getByRole('combobox'), 'init value')];
+                        case 2:
+                            _a.sent();
+                            return [4 /*yield*/, user.click(screen.getByText('Create "init value" as new Address'))];
+                        case 3:
+                            _a.sent();
+                            expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri, {
+                                attributes: {
+                                    FirstName: [
+                                        {
+                                            type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                            uri: expect.any(String),
+                                            value: 'init value'
+                                        }
+                                    ]
+                                },
+                                timestamp: expect.any(Number),
+                                type: 'configuration/entityTypes/Location',
+                                uri: expect.any(String)
+                            });
+                            expect(mdmActions.entityCreated).toHaveBeenCalledWith({
+                                attributes: {
+                                    FirstName: [
+                                        {
+                                            type: 'configuration/entityTypes/Location/attributes/FirstName',
+                                            uri: expect.any(String),
+                                            value: 'init value'
+                                        }
+                                    ]
+                                },
+                                timestamp: expect.any(Number),
+                                type: 'configuration/entityTypes/Location',
+                                uri: expect.any(String)
+                            });
+                            expect(mdmAction).toHaveBeenCalledTimes(2);
+                            return [2 /*return*/];
                     }
-                }, 'entities/uri$$outdatedEntity': {
-                    uri: 'entities/uri$$outdatedEntity',
-                    attributes: {}
-                }, 'entities/uri$$notRelatedEntity': {
-                    uri: 'entities/uri$$notRelatedEntity',
-                    attributes: {}
-                } }));
-            component.setProps({ test: 1 });
-            findCancelButton(component).find('button').simulate('click');
-            expect(mdmActions.entityCreated).toHaveBeenCalledWith(initialAllModifiedEntities['entities/uri$$addressEntity1']);
-            expect(mdmActions.entityCreated).toHaveBeenCalledWith(initialAllModifiedEntities['entities/uri$$locationEntity']);
-            expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$outdatedEntity');
-            expect(mdmActions.entityDeleted).not.toHaveBeenCalledWith('entities/uri$$notRelatedEntity');
-            expect(mdmActions.errorsSet).toHaveBeenCalledWith([]);
-            expect(mdmActions.closeRelationEditor).toHaveBeenCalledWith(config.id, connection.relation.relationUri);
-            expect(mdmAction).toHaveBeenCalledTimes(5);
-        });
-    });
-    describe('EntitySelector behavior', function () {
-        describe('onCreate behavior', function () {
-            it('should create new entity and call events for saving it in relation and in modified entities store slice', function () {
-                var mockedNewEntity = { uri: 'entities/uri$$1' };
-                createTemporaryEntity.mockReturnValue(mockedNewEntity);
-                getEntityType.mockReturnValue({ dataLabelPattern: '{Name}' });
-                var connection = {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: 'configuration/relationTypes/AccountTeam'
-                    },
-                    entity: {}
-                };
-                var entityTypeUri = 'configuration/entityTypes/HCP';
-                var metadata = { relationTypes: [] };
-                var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: metadata });
-                var component = setUp({ props: props });
-                var entitySelector = component.find(EntitySelector);
-                expect(entitySelector.length).toBe(1);
-                entitySelector.prop('onCreate')(entityTypeUri);
-                expect(getEntityType).toHaveBeenCalledWith(metadata, entityTypeUri);
-                expect(createTemporaryEntity).toHaveBeenCalledWith(expect.objectContaining({ entityTypeUri: entityTypeUri }));
-                expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(config.id, connection.relation.relationUri, mockedNewEntity);
-                expect(mdmActions.entityCreated).toHaveBeenCalledWith(mockedNewEntity);
-                expect(mdmAction).toHaveBeenCalledTimes(2);
-            });
-            it('should delete previous temp (modified) entity before creating new one', function () {
-                var mockedNewEntity = { uri: 'entities/uri$$1' };
-                createTemporaryEntity.mockReturnValue(mockedNewEntity);
-                getEntityType.mockReturnValue({ dataLabelPattern: '{Name}' });
-                var connection = {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: 'configuration/relationTypes/AccountTeam'
-                    },
-                    entity: { entityUri: 'entities/uri$$prev' }
-                };
-                var modifiedEntity = { uri: 'entities/uri$$prev' };
-                var entityTypeUri = 'configuration/entityTypes/HCP';
-                var metadata = { relationTypes: [] };
-                var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: metadata });
-                var mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntity: modifiedEntity });
-                var component = setUp({ props: props, mdmValues: mdmValues });
-                var entitySelector = component.find(EntitySelector);
-                expect(entitySelector.length).toBe(1);
-                entitySelector.prop('onCreate')(entityTypeUri);
-                expect(getEntityType).toHaveBeenCalledWith(metadata, entityTypeUri);
-                expect(createTemporaryEntity).toHaveBeenCalledWith(expect.objectContaining({ entityTypeUri: entityTypeUri }));
-                expect(mdmActions.setInitialInfo).toHaveBeenCalledWith(config.id, relationUri, modifiedEntity);
-                expect(mdmActions.entityDeleted).toHaveBeenCalledWith('entities/uri$$prev');
-                expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(config.id, connection.relation.relationUri, mockedNewEntity);
-                expect(mdmActions.entityCreated).toHaveBeenCalledWith(mockedNewEntity);
-                expect(mdmAction).toHaveBeenCalledTimes(4);
-            });
-            it('should create new entity with init value and call events when onCreate prop was called with initValue argument', function () {
-                var connection = {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: 'configuration/relationTypes/AccountTeam'
-                    },
-                    entity: {}
-                };
-                var entityTypeUri = 'configuration/entityTypes/HCP';
-                var entityType = {
-                    uri: 'configuration/entityTypes/HCP',
-                    label: 'HCP',
-                    attributes: [
-                        {
-                            name: 'Name',
-                            type: 'String',
-                            uri: 'configuration/entityTypes/HCP/attributes/Name',
-                            access: ['CREATE', 'READ']
-                        },
-                        {
-                            name: 'Int',
-                            type: 'Int',
-                            uri: 'configuration/entityTypes/HCP/attributes/Int',
-                            access: ['CREATE', 'READ']
-                        },
-                        {
-                            name: 'UsedInBusinessCard',
-                            type: 'String',
-                            uri: 'configuration/entityTypes/HCP/attributes/UsedInBusinessCard',
-                            access: ['CREATE', 'READ']
-                        },
-                        {
-                            name: 'DataLabelSimple',
-                            type: 'String',
-                            uri: 'configuration/entityTypes/HCP/attributes/DataLabelSimple',
-                            access: []
-                        },
-                        {
-                            name: 'Required',
-                            type: 'String',
-                            required: true,
-                            uri: 'configuration/entityTypes/HCP/attributes/Required',
-                            access: []
-                        }
-                    ],
-                    dataLabelPattern: '{DataLabelSimple} {OtherSimple}',
-                    businessCardAttributeURIs: [
-                        'configuration/entityTypes/HCP/attributes/Employment',
-                        'configuration/entityTypes/HCP/attributes/FirstName',
-                        'configuration/entityTypes/HCP/attributes/UsedInBusinessCard'
-                    ]
-                };
-                var mockedNewEntity = { uri: 'entities/uri$$1' };
-                var initValue = '123';
-                var metadata = { relationTypes: [] };
-                getEntityType.mockReturnValue(entityType);
-                createTemporaryEntity.mockReturnValue(mockedNewEntity);
-                var props = __assign(__assign({}, defaultProps), { connection: connection, config: config, metadata: metadata });
-                var component = setUp({ props: props });
-                var entitySelector = component.find(EntitySelector);
-                expect(entitySelector.length).toBe(1);
-                entitySelector.prop('onCreate')(entityTypeUri, initValue);
-                expect(getEntityType).toHaveBeenCalledWith(metadata, entityTypeUri);
-                expect(createTemporaryEntity).toHaveBeenCalledWith({
-                    entityTypeUri: entityTypeUri,
-                    initValue: initValue,
-                    attributeTypes: [
-                        {
-                            name: 'UsedInBusinessCard',
-                            type: 'String',
-                            uri: 'configuration/entityTypes/HCP/attributes/UsedInBusinessCard',
-                            access: ['CREATE', 'READ']
-                        }
-                    ],
-                    metadata: metadata,
-                    mode: 'Editing'
                 });
-                expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(config.id, connection.relation.relationUri, mockedNewEntity);
-                expect(mdmActions.entityCreated).toHaveBeenCalledWith(mockedNewEntity);
-                expect(mdmAction).toHaveBeenCalledTimes(2);
-            });
+            }); });
         });
-        describe('onChange behavior', function () {
-            it('should set connection entity', function () {
-                var connection = {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: 'configuration/relationTypes/AccountTeam'
-                    },
-                    entity: {}
-                };
-                var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-                var component = setUp({ props: props });
-                var entitySelector = component.find(EntitySelector);
-                expect(entitySelector.length).toBe(1);
-                var entity = { uri: 'entities/123' };
-                entitySelector.prop('onChange')(entity);
-                expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(config.id, connection.relation.relationUri, entity);
-                expect(mdmAction).toHaveBeenCalledTimes(1);
+        describe('changing', function () {
+            beforeEach(function () {
+                typeAheadSearch.mockResolvedValue([
+                    { type: 'configuration/entityTypes/Location', label: 'location entity 1', uri: 'entities/0C32GxR' },
+                    { type: 'configuration/entityTypes/Location', label: 'location entity 2', uri: 'entities/0G49Cnu' }
+                ]);
             });
-            it('should deactivate error if it was set', function () {
-                var connection = {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: 'configuration/relationTypes/AccountTeam'
-                    },
-                    entity: {}
-                };
-                var error = {
-                    uri: 'uri',
-                    type: 'missedRefEntity',
-                    message: 'alarm!',
-                    attributeTypeUri: 'configuration/relationTypes/AccountTeam',
-                    parentUri: relationUri
-                };
-                var profileErrors = [error];
-                var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-                var mdmValues = __assign(__assign({}, defaultMdmValues), { profileErrors: profileErrors });
-                var component = setUp({ props: props, mdmValues: mdmValues });
-                var entitySelector = component.find(EntitySelector);
-                expect(entitySelector.length).toBe(1);
-                var entity = { uri: 'entities/123' };
-                entitySelector.prop('onChange')(entity);
-                expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(config.id, connection.relation.relationUri, entity);
-                expect(mdmActions.errorDeactivated).toHaveBeenCalledWith("".concat(error.attributeTypeUri, "-").concat(error.uri, "-").concat(error.parentUri));
-                expect(mdmAction).toHaveBeenCalledTimes(2);
-            });
-            it('should clear connection entity and modified entity if it set', function () {
-                var connection = {
-                    relation: {
-                        relationUri: relationUri,
-                        relationType: 'configuration/relationTypes/AccountTeam'
-                    },
-                    entity: { entityUri: 'entities/uri$$1' }
-                };
-                var modifiedEntity = { uri: 'entities/uri$$1' };
-                var props = __assign(__assign({}, defaultProps), { connection: connection, config: config });
-                var mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntity: modifiedEntity, initialModifiedEntity: modifiedEntity });
-                var component = setUp({ props: props, mdmValues: mdmValues });
-                var entitySelector = component.find(EntitySelector);
-                expect(entitySelector.length).toBe(1);
-                var entity = {};
-                entitySelector.prop('onChange')(entity);
-                expect(mdmActions.entityDeleted).toHaveBeenCalledWith(modifiedEntity.uri);
-                expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(config.id, connection.relation.relationUri, entity);
-                expect(mdmAction).toHaveBeenCalledTimes(2);
+            afterEach(function () {
+                jest.clearAllMocks();
             });
+            it('should set connection entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var user;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            user = setUp().user;
+                            return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, user.click(screen.getByText('location entity 1'))];
+                        case 2:
+                            _a.sent();
+                            expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri, {
+                                entityType: defaultProps.metadata.entityTypes[1],
+                                label: 'location entity 1',
+                                type: 'configuration/entityTypes/Location',
+                                uri: 'entities/0C32GxR'
+                            });
+                            expect(mdmAction).toHaveBeenCalledTimes(1);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('should deactivate error if it was set', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var error, mdmValues, user;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            error = {
+                                parentUri: defaultRelation.relationUri,
+                                uri: 'uri',
+                                attributeTypeUri: defaultRelation.relationType,
+                                message: 'Entity is required',
+                                type: ErrorType.missedRefEntity
+                            };
+                            mdmValues = __assign(__assign({}, defaultMdmValues), { profileErrors: [error] });
+                            setUp({ mdmValues: mdmValues });
+                            user = setUp().user;
+                            return [4 /*yield*/, user.click(screen.getAllByTestId('select-dropdown-indicator')[0])];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, user.click(screen.getByText('location entity 1'))];
+                        case 2:
+                            _a.sent();
+                            expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri, {
+                                entityType: defaultProps.metadata.entityTypes[1],
+                                label: 'location entity 1',
+                                type: 'configuration/entityTypes/Location',
+                                uri: 'entities/0C32GxR'
+                            });
+                            expect(mdmActions.errorDeactivated).toHaveBeenCalledWith("".concat(error.attributeTypeUri, "-").concat(error.uri, "-").concat(error.parentUri));
+                            expect(mdmAction).toHaveBeenCalledTimes(2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('should clear connection entity and modified entity if it set', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var entityUri, modifiedEntity, connection, mdmValues, props, user;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            entityUri = 'entities/uri$$kAp2KJM8';
+                            modifiedEntity = { type: 'configuration/entityTypes/Location', uri: entityUri, attributes: {} };
+                            connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: entityUri, entityType: 'configuration/entityTypes/Location' } });
+                            mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntities: (_a = {}, _a[entityUri] = modifiedEntity, _a) });
+                            props = __assign(__assign({}, defaultProps), { connection: connection });
+                            user = setUp({ mdmValues: mdmValues, props: props }).user;
+                            mdmAction.mockClear();
+                            return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                        case 1:
+                            _b.sent();
+                            return [4 /*yield*/, user.click(screen.getByText('location entity 1'))];
+                        case 2:
+                            _b.sent();
+                            expect(mdmActions.entityDeleted).toHaveBeenCalledWith(entityUri);
+                            expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(defaultProps.config.id, defaultProps.connection.relation.relationUri, {
+                                entityType: defaultProps.metadata.entityTypes[1],
+                                label: 'location entity 1',
+                                type: 'configuration/entityTypes/Location',
+                                uri: 'entities/0C32GxR'
+                            });
+                            expect(mdmAction).toHaveBeenCalledTimes(2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
         });
     });
-    describe('useScrollToAttributeError tests', function () {
+    describe('errors highlighting', function () {
         var fullError = {
-            type: 'invalid',
+            type: ErrorType.invalid,
             attributeTypeUri: defaultProps.connection.relation.relationType,
             parentUri: defaultProps.connection.relation.relationUri,
             uri: 'someUrl',
-            source: 'validationService',
-            severity: 'ERROR'
+            source: ErrorSource.validationService,
+            severity: ErrorSeverity.ERROR
         };
-        it('should not highlight error if it have uri', function () {
-            var component = setUp({ contextError: fullError });
-            expect(component.find('RelationEditor').prop('highlightedError')).toBe(null);
-            expect(useScrollToAttributeError.mock.calls[0][0]).toMatchObject({
-                highlightedError: null,
-                isSimple: true
+        it('should not highlight error if it have uri', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setUp({ error: fullError });
+                        return [4 /*yield*/, screen.findByText('Select Address profile')];
+                    case 1:
+                        _a.sent();
+                        expect(scrollIntoRef).not.toHaveBeenCalledWith();
+                        return [2 /*return*/];
+                }
             });
-        });
-        it('should highlight error if it have same parent uri, empty uri, and attribute type uri', function () {
-            var error = __assign(__assign({}, fullError), { uri: '' });
-            var component = setUp({ contextError: error });
-            var highlightedError = {
-                element: error,
-                highlightError: highlightErrorSpy,
-                scrollIntoRef: scrollIntoRefSpy,
-                type: ScrollType.Error
-            };
-            expect(component.find('RelationEditor').prop('highlightedError')).toMatchObject(highlightedError);
-            expect(useScrollToAttributeError.mock.calls[0][0]).toMatchObject({ highlightedError: highlightedError, isSimple: true });
-        });
+        }); });
+        it('should highlight error if it have same parent uri, empty uri, and attribute type uri', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        error = __assign(__assign({}, fullError), { uri: '' });
+                        setUp({ error: error });
+                        return [4 /*yield*/, screen.findByText('Select Address profile')];
+                    case 1:
+                        _a.sent();
+                        expect(scrollIntoRef).toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
 });