@reltio/components 1.4.1906 → 1.4.1907

package/esm/ConnectionEditor/ConnectionEditor.test.js

@@ -45,296 +45,339 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-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];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var _a, _b;
 import React from 'react';
-import { mount } from 'enzyme';
-import { act } from 'react-dom/test-utils';
-import { ACTIVENESS_ATTR_TYPES, Directions } from '@reltio/mdm-sdk';
+import { Directions, typeAheadSearch } from '@reltio/mdm-sdk';
+import userEvent from '@testing-library/user-event';
+import { render, screen } from '@testing-library/react';
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
+import { AdapterMoment } from '@mui/x-date-pickers/AdapterMoment';
+import { getMuiIconsByName } from '../test-utils';
 import { MdmModuleProvider } from '../contexts/MdmModuleContext';
-import { EditModeAttributesList } from '../EditModeAttributesList';
-import { EntitySelector } from '../EntitySelector';
-import { ConnectionRelationTypeSelector } from '../ConnectionRelationTypeSelector';
-import { ErrorWrapper } from '../ErrorWrapper';
 import { ConnectionEditor } from './ConnectionEditor';
-jest.mock('../EntitySelector', function () { return ({
-    EntitySelector: function () { return null; }
-}); });
-jest.mock('../EditModeAttributesList', function () { return ({
-    EditModeAttributesList: function () { return null; }
-}); });
-var newConnection = {
-    relation: {
-        uri: 'relations/uri$$123',
-        attributes: {},
-        type: undefined
-    },
-    entity: null
-};
-var relatedEntity = {
-    uri: 'entities/entity123',
-    type: 'configuration/entityTypes/HCP'
-};
-var metadata = {
-    uri: 'configuration',
-    entityTypes: [
-        {
-            uri: 'configuration/entityTypes/HCP'
-        },
-        {
-            uri: 'configuration/entityTypes/HCO'
-        },
-        {
-            uri: 'configuration/entityTypes/Committee'
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getLookups: jest.fn(function () { return Promise.resolve(); }), getDependentLookups: jest.fn(function () { return Promise.resolve(); }), resolveLookupsList: jest.fn(function () { return Promise.resolve(); }), typeAheadSearch: jest.fn().mockReturnValue(Promise.resolve([])) })); });
+describe('ConnectionEditor test', function () {
+    var newConnection = {
+        relation: {
+            uri: 'relations/uri$$123',
+            attributes: {},
+            type: undefined
         },
-        {
-            uri: 'configuration/entityTypes/Location'
-        }
-    ],
-    relationTypes: [
-        {
-            uri: 'configuration/relationTypes/HeadNursing',
-            label: 'Head of Nursing',
-            startObject: {
-                objectTypeURI: 'configuration/entityTypes/HCP',
-                uri: 'configuration/relationTypes/HeadNursing/startObject'
+        entity: null
+    };
+    var relatedEntity = {
+        uri: 'entities/entity123',
+        type: 'configuration/entityTypes/HCP'
+    };
+    var metadata = {
+        uri: 'configuration',
+        entityTypes: [
+            {
+                uri: 'configuration/entityTypes/HCP',
+                label: 'HCP'
+            },
+            {
+                uri: 'configuration/entityTypes/HCO',
+                label: 'HCO'
             },
-            endObject: {
-                objectTypeURI: 'configuration/entityTypes/HCO',
-                uri: 'configuration/relationTypes/HeadNursing/endObject'
+            {
+                uri: 'configuration/entityTypes/Committee',
+                label: 'Committee'
             },
-            attributes: [
-                {
-                    label: 'Affiliation SubType',
-                    name: 'AffiliationSubType',
-                    type: 'String',
-                    lookupCode: 'AFFILIATION_SUB_TYPE_CD',
-                    uri: 'configuration/relationTypes/HCPtoHCA/attributes/AffiliationSubType'
+            {
+                uri: 'configuration/entityTypes/Location',
+                label: 'Location'
+            }
+        ],
+        relationTypes: [
+            {
+                uri: 'configuration/relationTypes/HeadNursing',
+                label: 'Head of Nursing',
+                startObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCP',
+                    uri: 'configuration/relationTypes/HeadNursing/startObject'
                 },
-                {
-                    label: 'Primary Affiliation Indicator',
-                    name: 'PrimaryAffiliationIndicator',
-                    type: 'Boolean',
-                    uri: 'configuration/relationTypes/HCPtoHCA/attributes/PrimaryAffiliationIndicator'
+                endObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCO',
+                    uri: 'configuration/relationTypes/HeadNursing/endObject'
+                },
+                direction: 'directed',
+                attributes: [
+                    {
+                        label: 'Affiliation SubType',
+                        name: 'AffiliationSubType',
+                        type: 'String',
+                        lookupCode: 'AFFILIATION_SUB_TYPE_CD',
+                        uri: 'configuration/relationTypes/HCPtoHCA/attributes/AffiliationSubType'
+                    },
+                    {
+                        label: 'First name',
+                        name: 'FirstName',
+                        type: 'String',
+                        uri: 'configuration/relationTypes/HCPtoHCA/attributes/FirstName'
+                    },
+                    {
+                        label: 'Primary Affiliation Indicator',
+                        name: 'PrimaryAffiliationIndicator',
+                        type: 'Boolean',
+                        uri: 'configuration/relationTypes/HCPtoHCA/attributes/PrimaryAffiliationIndicator'
+                    },
+                    {
+                        label: 'RelFirstLevelNested',
+                        name: 'RelFirstLevelNested',
+                        type: 'Nested',
+                        uri: 'configuration/relationTypes/HCPtoHCA/attributes/RefFirstLevelNested',
+                        attributes: [
+                            {
+                                label: 'FirstLevelNestedSub1',
+                                name: 'FirstLevelNestedSub1',
+                                type: 'String',
+                                lookupCode: 'LANG_CD',
+                                uri: 'configuration/relationTypes/HCPtoHCA/attributes/RefFirstLevelNested/attributes/FirstLevelNestedSub1'
+                            }
+                        ]
+                    }
+                ]
+            },
+            {
+                uri: 'configuration/relationTypes/HasAddress',
+                label: 'has address',
+                startObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCP',
+                    uri: 'configuration/relationTypes/HasAddress/startObject'
                 },
-                {
-                    label: 'RelFirstLevelNested',
-                    name: 'RelFirstLevelNested',
-                    type: 'Nested',
-                    uri: 'configuration/relationTypes/HCPtoHCA/attributes/RefFirstLevelNested',
-                    attributes: [
-                        {
-                            label: 'FirstLevelNestedSub1',
-                            name: 'FirstLevelNestedSub1',
-                            type: 'String',
-                            lookupCode: 'LANG_CD',
-                            uri: 'configuration/relationTypes/HCPtoHCA/attributes/RefFirstLevelNested/attributes/FirstLevelNestedSub1'
-                        }
-                    ]
+                endObject: {
+                    objectTypeURI: 'configuration/entityTypes/Location',
+                    uri: 'configuration/relationTypes/HasAddress/endObject'
                 }
-            ]
-        },
-        {
-            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'
+            {
+                uri: 'configuration/relationTypes/IsInCommittee',
+                label: 'is in committee',
+                startObject: {
+                    objectTypeURI: 'configuration/entityTypes/Committee',
+                    uri: 'configuration/relationTypes/IsInCommittee/startObject'
+                },
+                endObject: {
+                    objectTypeURI: 'configuration/entityTypes/HCP',
+                    uri: 'configuration/relationTypes/IsInCommittee/endObject'
+                }
             }
-        },
-        {
-            uri: 'configuration/relationTypes/IsInCommittee',
-            label: 'is in committee',
-            startObject: {
-                objectTypeURI: 'configuration/entityTypes/Committee',
-                uri: 'configuration/relationTypes/IsInCommittee/startObject'
+        ]
+    };
+    var inRelationTypes = [
+        __assign(__assign({}, metadata.relationTypes[2]), { startObject: __assign(__assign({}, metadata.relationTypes[2].startObject), { objectType: {
+                    uri: 'configuration/entityTypes/HCP'
+                } }), endObject: __assign(__assign({}, metadata.relationTypes[2].endObject), { objectType: {
+                    uri: 'configuration/entityTypes/HCO'
+                } }) })
+    ];
+    var outRelationTypes = [
+        __assign(__assign({}, metadata.relationTypes[0]), { startObject: __assign(__assign({}, metadata.relationTypes[0].startObject), { objectType: {
+                    uri: 'configuration/entityTypes/HCP'
+                } }), endObject: __assign(__assign({}, metadata.relationTypes[0].endObject), { objectType: {
+                    uri: 'configuration/entityTypes/HCO'
+                } }) }),
+        __assign(__assign({}, metadata.relationTypes[1]), { startObject: __assign(__assign({}, metadata.relationTypes[1].startObject), { objectType: {
+                    uri: 'configuration/entityTypes/HCP'
+                } }), endObject: __assign(__assign({}, metadata.relationTypes[1].endObject), { objectType: {
+                    uri: 'configuration/entityTypes/Location'
+                } }) })
+    ];
+    var initConnection = {
+        relation: {
+            attributes: {
+                FirstName: [
+                    {
+                        type: 'configuration/relationTypes/HCPtoHCA/attributes/FirstName',
+                        ov: true,
+                        value: 'HCP_5',
+                        uri: 'relations/19oYeyx1/attributes/FirstName/1dg2njmxf'
+                    }
+                ]
             },
-            endObject: {
-                objectTypeURI: 'configuration/entityTypes/HCP',
-                uri: 'configuration/relationTypes/IsInCommittee/endObject'
-            }
-        }
-    ]
-};
-var inRelationTypes = (_a = metadata.relationTypes) === null || _a === void 0 ? void 0 : _a.slice(2, 3);
-var outRelationTypes = (_b = metadata.relationTypes) === null || _b === void 0 ? void 0 : _b.slice(0, 2);
-var initConnection = {
-    relation: {
-        attributes: {
-            FirstName: [
-                {
-                    type: 'configuration/entityTypes/HCP/attributes/FirstName',
-                    ov: true,
-                    value: 'HCP_5',
-                    uri: 'entities/19oYeyx1/attributes/FirstName/1dg2njmxf'
-                }
-            ]
+            uri: 'relation/uri',
+            type: 'configuration/relationTypes/HeadNursing',
+            direction: 'out',
+            startDate: 123
         },
-        uri: 'relation/uri',
-        type: 'configuration/relationTypes/HeadNursing',
-        direction: 'out',
-        startDate: 123
-    },
-    entity: {
-        type: 'configuration/entityTypes/HCO',
-        uri: 'entities/uriHCO'
-    }
-};
-var props = {
-    onChangeAttribute: jest.fn(),
-    onAddAttributes: jest.fn(),
-    onRemoveAttribute: jest.fn(),
-    showEmptyEditors: true
-};
-var mdmValues = {
-    metadata: metadata,
-    globalSearchRequestOptions: {}
-};
-var setUpMount = function (extraProps) {
-    var Component = function (props) { return (React.createElement(MdmModuleProvider, { values: mdmValues },
-        React.createElement(ConnectionEditor, __assign({}, props)))); };
-    return mount(React.createElement(Component, __assign({}, props, extraProps)));
-};
-describe('ConnectionEditor test', function () {
+        entity: {
+            type: 'configuration/entityTypes/HCO',
+            uri: 'entities/uriHCO',
+            label: 'initRelationEntity'
+        }
+    };
+    var mdmValues = {
+        metadata: metadata,
+        globalSearchRequestOptions: {},
+        dependentLookups: { editors: {}, structure: {}, initedTypeUris: [] },
+        lookups: {}
+    };
+    var onChangeAttribute = jest.fn();
+    var onAddAttributes = jest.fn();
+    var onRemoveAttribute = jest.fn();
+    var onChangeRelationType = jest.fn();
+    var onChangeEntity = jest.fn();
+    var defaultProps = {
+        connection: initConnection,
+        onChangeAttribute: onChangeAttribute,
+        onAddAttributes: onAddAttributes,
+        onRemoveAttribute: onRemoveAttribute,
+        showEmptyEditors: true
+    };
+    var propsWithRelations = __assign(__assign({}, defaultProps), { connection: newConnection, relatedEntity: relatedEntity, inRelationTypes: inRelationTypes, outRelationTypes: outRelationTypes, onChangeRelationType: onChangeRelationType, onChangeEntity: onChangeEntity });
+    var setUp = function (props) {
+        if (props === void 0) { props = defaultProps; }
+        var Providers = function (_a) {
+            var children = _a.children;
+            return (React.createElement(LocalizationProvider, { dateAdapter: AdapterMoment },
+                React.createElement(MdmModuleProvider, { values: mdmValues }, children)));
+        };
+        var user = userEvent.setup();
+        return __assign({ user: user }, render(React.createElement(ConnectionEditor, __assign({}, props)), { wrapper: Providers }));
+    };
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
     it('should render EditModeAttributesList', function () {
-        var _a;
-        var component = setUpMount({ connection: initConnection });
-        expect(component.find(EditModeAttributesList)).toHaveLength(1);
-        expect(component.find(EditModeAttributesList).prop('attrTypes')).toEqual(__spreadArray(__spreadArray([], ACTIVENESS_ATTR_TYPES, true), (((_a = metadata.relationTypes) === null || _a === void 0 ? void 0 : _a[0].attributes) || []), true));
-        expect(component.find(EditModeAttributesList).prop('entity')).toEqual({
-            attributes: initConnection.relation.attributes,
-            startDate: 123
-        });
-        expect(component.find(EditModeAttributesList).prop('showEmptyEditors')).toBe(true);
-        expect(component.find(EditModeAttributesList).prop('mode')).toBe('Editing');
-        expect(component.find(EditModeAttributesList).prop('parentUri')).toBe(initConnection.relation.uri);
-        expect(component.find(EditModeAttributesList).prop('onAddAttributes')).toBe(props.onAddAttributes);
-        expect(component.find(EditModeAttributesList).prop('onChangeAttribute')).toBe(props.onChangeAttribute);
-        expect(component.find(EditModeAttributesList).prop('onDeleteAttribute')).toBe(props.onRemoveAttribute);
+        setUp();
+        expect(screen.queryByText('First name')).toBeInTheDocument();
+        expect(screen.queryAllByTestId('reltio-edit-attribute')).toHaveLength(6);
     });
+    it('should call onAddAttributes', 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.getByRole('button', { name: 'More attributes' }))];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, user.click(screen.getByRole('menuitem', { name: 'First name' }))];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, user.click(screen.getByRole('presentation').firstChild)];
+                case 3:
+                    _a.sent();
+                    expect(onAddAttributes).toHaveBeenCalledWith([
+                        { attributeType: metadata.relationTypes[0].attributes[1], parentUri: initConnection.relation.uri }
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should call onChangeAttribute', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var user, firstNameValueInput;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    user = setUp().user;
+                    firstNameValueInput = screen.getAllByRole('textbox')[2];
+                    return [4 /*yield*/, user.type(firstNameValueInput, 'newValue{Enter}')];
+                case 1:
+                    _a.sent();
+                    expect(onChangeAttribute).toHaveBeenCalledWith({
+                        attributeType: metadata.relationTypes[0].attributes[1],
+                        uri: initConnection.relation.attributes.FirstName[0].uri,
+                        value: 'HCP_5newValue'
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should call onRemoveAttribute', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var user, firstNameDeleteButton;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    user = setUp().user;
+                    firstNameDeleteButton = getMuiIconsByName('Delete')[3];
+                    return [4 /*yield*/, user.click(firstNameDeleteButton)];
+                case 1:
+                    _a.sent();
+                    expect(onRemoveAttribute).toHaveBeenCalledWith({
+                        attributeType: metadata.relationTypes[0].attributes[1],
+                        uri: initConnection.relation.attributes.FirstName[0].uri
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should render ConnectionRelationTypeSelector and EntitySelector', function () {
-        var props = {
-            connection: initConnection,
-            relatedEntity: relatedEntity,
-            inRelationTypes: inRelationTypes,
-            outRelationTypes: outRelationTypes,
-            onChangeRelationType: jest.fn(),
-            onChangeEntity: jest.fn()
-        };
-        var component = setUpMount(props);
-        expect(component.find(ConnectionRelationTypeSelector)).toHaveLength(1);
-        expect(component.find(ErrorWrapper)).toHaveLength(1);
-        expect(component.find(EntitySelector)).toHaveLength(1);
-        var compatibleRelation = {
-            relationType: initConnection.relation.type,
-            direction: initConnection.relation.direction
-        };
-        expect(component.find(ConnectionRelationTypeSelector).prop('relation')).toEqual(compatibleRelation);
-        expect(component.find(EntitySelector).prop('onChange')).toBe(props.onChangeEntity);
-        var compatibleEntity = {
-            entityUri: initConnection.entity.uri,
-            entityType: initConnection.entity.type,
-            entityLabel: '<No label>'
-        };
-        expect(component.find(EntitySelector).prop('entity')).toEqual(compatibleEntity);
-        expect(component.find(EntitySelector).prop('entityTypesUris')).toEqual(['configuration/entityTypes/HCO']);
-    });
-    it('should set entityTypesUris prop for EntitySelector', function () {
-        var props = {
-            connection: newConnection,
-            relatedEntity: relatedEntity,
-            inRelationTypes: inRelationTypes,
-            outRelationTypes: outRelationTypes,
-            onChangeRelationType: jest.fn(),
-            onChangeEntity: jest.fn()
-        };
-        var component = setUpMount(props);
-        expect(component.find(EntitySelector).prop('entityTypesUris')).toEqual([
-            'configuration/entityTypes/HCO',
-            'configuration/entityTypes/Location',
-            'configuration/entityTypes/Committee'
-        ]);
+        setUp(__assign(__assign({}, propsWithRelations), { connection: initConnection }));
+        expect(screen.queryByText('Head of Nursing')).toBeInTheDocument();
+        expect(screen.queryByText('Select HCO profile')).toBeInTheDocument();
     });
+    it('should call onChangeEntity for EntitySelector', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var newEntity, wrongEntity, user, profileSelector;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    newEntity = {
+                        uri: 'entities/entityCommittee',
+                        type: 'configuration/entityTypes/Committee',
+                        label: 'Committee'
+                    };
+                    wrongEntity = {
+                        uri: 'entities/wrongEntity',
+                        type: 'configuration/entityTypes/HCP',
+                        label: 'WrongEntity'
+                    };
+                    typeAheadSearch.mockResolvedValueOnce([newEntity]);
+                    user = setUp(propsWithRelations).user;
+                    profileSelector = screen.getAllByRole('textbox')[1];
+                    return [4 /*yield*/, user.click(profileSelector)];
+                case 1:
+                    _a.sent();
+                    expect(screen.queryByText(wrongEntity.label)).not.toBeInTheDocument();
+                    return [4 /*yield*/, user.click(screen.getByRole('menuitem', { name: 'C Committee' }))];
+                case 2:
+                    _a.sent();
+                    expect(onChangeEntity).toHaveBeenCalledWith(__assign(__assign({}, newEntity), { entityType: metadata.entityTypes[2] }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should call onChangeRelationType for ConnectionRelationTypeSelector, if relation type was changed', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var onChangeRelationType, component, newRelationType;
+        var user, relationshipTypeSelector;
         return __generator(this, function (_a) {
-            onChangeRelationType = jest.fn();
-            component = setUpMount({
-                connection: newConnection,
-                relatedEntity: relatedEntity,
-                inRelationTypes: inRelationTypes,
-                outRelationTypes: outRelationTypes,
-                onChangeRelationType: onChangeRelationType,
-                onChangeEntity: jest.fn()
-            });
-            expect(onChangeRelationType).not.toHaveBeenCalledWith();
-            newRelationType = {
-                type: { uri: 'configuration/relationTypes/IsInCommittee' },
-                direction: Directions.OUT
-            };
-            act(function () {
-                component.find(ConnectionRelationTypeSelector).prop('onChange')(newRelationType);
-            });
-            component.update();
-            expect(onChangeRelationType).toHaveBeenCalledWith({
-                type: newRelationType.type.uri,
-                direction: newRelationType.direction
-            });
-            return [2 /*return*/];
+            switch (_a.label) {
+                case 0:
+                    user = setUp(propsWithRelations).user;
+                    expect(onChangeRelationType).not.toHaveBeenCalled();
+                    relationshipTypeSelector = screen.getAllByRole('textbox')[0];
+                    return [4 /*yield*/, user.click(relationshipTypeSelector)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, user.click(screen.getByRole('menuitem', { name: 'H L has address undefined ↔ undefined' }))];
+                case 2:
+                    _a.sent();
+                    expect(onChangeRelationType).toHaveBeenCalledWith({
+                        direction: Directions.OUT,
+                        type: 'configuration/relationTypes/HasAddress'
+                    });
+                    return [2 /*return*/];
+            }
         });
     }); });
     it('should call onChangeRelationType on mount for ConnectionRelationTypeSelector, if available relation type is only one', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var onChangeRelationType, component;
         return __generator(this, function (_a) {
-            onChangeRelationType = jest.fn();
-            component = setUpMount({
-                connection: newConnection,
-                relatedEntity: relatedEntity,
-                inRelationTypes: inRelationTypes === null || inRelationTypes === void 0 ? void 0 : inRelationTypes.slice(0, 1),
-                outRelationTypes: [],
-                onChangeRelationType: onChangeRelationType,
-                onChangeEntity: jest.fn()
-            });
-            expect(component.find(ConnectionRelationTypeSelector)).toHaveLength(1);
+            setUp(__assign(__assign({}, propsWithRelations), { inRelationTypes: inRelationTypes === null || inRelationTypes === void 0 ? void 0 : inRelationTypes.slice(0, 1), outRelationTypes: [] }));
             expect(onChangeRelationType).toHaveBeenCalledWith({
                 type: 'configuration/relationTypes/IsInCommittee',
-                direction: 'in'
+                direction: Directions.IN
             });
             return [2 /*return*/];
         });
     }); });
     it('should call onChangeRelationType for ConnectionRelationTypeSelector, after entity selected and compatible relation type is only one', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var onChangeRelationType, component;
+        var rerender, newProps;
         return __generator(this, function (_a) {
-            onChangeRelationType = jest.fn();
-            component = setUpMount({
-                connection: newConnection,
-                relatedEntity: relatedEntity,
-                inRelationTypes: inRelationTypes,
-                outRelationTypes: outRelationTypes,
-                onChangeRelationType: onChangeRelationType,
-                onChangeEntity: jest.fn()
-            });
-            expect(component.find(ConnectionRelationTypeSelector)).toHaveLength(1);
-            component.setProps({
-                connection: __assign(__assign({}, newConnection), { entity: {
+            rerender = setUp(propsWithRelations).rerender;
+            newProps = __assign(__assign({}, propsWithRelations), { connection: __assign(__assign({}, newConnection), { entity: {
                         uri: 'entities/entityCommittee',
                         type: 'configuration/entityTypes/Committee'
-                    } })
-            });
-            component.update();
+                    } }) });
+            rerender(React.createElement(ConnectionEditor, __assign({}, newProps)));
             expect(onChangeRelationType).toHaveBeenCalledWith({
                 type: 'configuration/relationTypes/IsInCommittee',
                 direction: 'in'
@@ -342,30 +385,4 @@ describe('ConnectionEditor test', function () {
             return [2 /*return*/];
         });
     }); });
-    it('should call onChangeEntity for EntitySelector', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var onChangeEntity, component, newEntity;
-        return __generator(this, function (_a) {
-            onChangeEntity = jest.fn();
-            component = setUpMount({
-                connection: newConnection,
-                relatedEntity: relatedEntity,
-                inRelationTypes: inRelationTypes,
-                outRelationTypes: outRelationTypes,
-                onChangeRelationType: jest.fn(),
-                onChangeEntity: onChangeEntity
-            });
-            newEntity = {
-                uri: 'entities/entityCommittee',
-                type: 'configuration/entityTypes/Committee',
-                label: 'Committee',
-                entityType: { uri: 'configuration/entityTypes/Committee' }
-            };
-            act(function () {
-                component.find(EntitySelector).prop('onChange')(newEntity);
-            });
-            component.update();
-            expect(onChangeEntity).toHaveBeenCalledWith(newEntity);
-            return [2 /*return*/];
-        });
-    }); });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.1906",
+  "version": "1.4.1907",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",