@reltio/components 1.4.1836-hf → 1.4.1837

package/esm/features/crosswalks/AttributesTable/AttributesTable.js

@@ -0,0 +1,119 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React, { memo, useCallback, useEffect, useMemo, useState } from 'react';
+import classnames from 'classnames';
+import i18n from 'ui-i18n';
+import { always, either, filter, isNil, keys, map, pipe, without, identity, both, move } from 'ramda';
+import { findAttributeTypeByUri, isReadableAttribute, makeAttrTypeUri } from '@reltio/mdm-sdk';
+import { BasicTable } from '../../../BasicTable';
+import { ColumnsSettings } from '../../../ColumnsSettings';
+import { useDynamicRowCellHeight } from '../../../hooks/useDynamicRowCellHeight';
+import { BasicViewHeader } from '../../../BasicViewHeader';
+import LinearLoadIndicator from '../../../components/LinearLoadIndicator/LinearLoadIndicator';
+import { ConfirmDeleteDialog } from '../../../ConfirmDeleteDialog';
+import { noop } from '../../../core';
+import { useMdmMetadata } from '../../../contexts/MdmModuleContext';
+import { COLUMNS_DATA, DEFAULT_VISIBLE_COLUMNS, getBasicTableColumnsData, getBasicTableRowsData } from './helpers';
+import { ConfirmEditIgnoredDialog } from './components/ConfirmEditIgnoredDialog';
+import { CommonRowCellRenderer } from './components/CommonRowCellRenderer';
+import { useStyles } from './styles';
+var DEFAULT_ROW_HEIGHT = 68;
+var getIdFromRowValue = function (rowValue) { return rowValue.ovValues.attributeType.uri; };
+var getRowCellKey = function (_a) {
+    var id = _a.columnData.id, cellIndex = _a.cellIndex, rowValue = _a.rowValue;
+    return "".concat(id, "[").concat(getIdFromRowValue(rowValue), "][").concat(cellIndex, "]");
+};
+var AttributesTable = function (_a) {
+    var entity = _a.entity, isLoading = _a.isLoading, crosswalksMap = _a.crosswalksMap, _b = _a.visibleColumns, visibleColumns = _b === void 0 ? DEFAULT_VISIBLE_COLUMNS : _b, onChangeVisibleColumns = _a.onChangeVisibleColumns, readOnly = _a.readOnly, _c = _a.onDelete, onDelete = _c === void 0 ? noop : _c, _d = _a.onPin, onPin = _d === void 0 ? noop : _d, _e = _a.onIgnore, onIgnore = _e === void 0 ? noop : _e, _f = _a.onEdit, onEdit = _f === void 0 ? noop : _f, _g = _a.onAdd, onAdd = _g === void 0 ? noop : _g, emptyTempAttributeUris = _a.emptyTempAttributeUris, selectedAttributeTypes = _a.selectedAttributeTypes, _h = _a.onSelectAttributeTypes, onSelectAttributeTypes = _h === void 0 ? noop : _h, additionalHeaderItems = _a.additionalHeaderItems, className = _a.className, activeSurvivorshipGroupUri = _a.activeSurvivorshipGroupUri;
+    var styles = useStyles();
+    var metadata = useMdmMetadata();
+    var visibleColumnsData = useMemo(function () {
+        return pipe(filter(function (_a) {
+            var id = _a.id;
+            return visibleColumns.includes(id);
+        }), getBasicTableColumnsData)(COLUMNS_DATA);
+    }, [visibleColumns]);
+    var _j = entity || {}, parentTypeUri = _j.type, parentUri = _j.uri, _k = _j.attributes, attributes = _k === void 0 ? {} : _k;
+    useEffect(function () {
+        if (entity && isNil(selectedAttributeTypes)) {
+            var initialAttrTypes = pipe(keys, without(['paging']), map(makeAttrTypeUri(parentTypeUri)), map(function (attrTypeUri) { return findAttributeTypeByUri(metadata, attrTypeUri, parentTypeUri); }), filter(both(identity, isReadableAttribute)))(attributes);
+            onSelectAttributeTypes(initialAttrTypes);
+        }
+    }, [entity, selectedAttributeTypes]);
+    var rowsData = useMemo(function () {
+        return parentTypeUri
+            ? getBasicTableRowsData(metadata, parentTypeUri, selectedAttributeTypes, visibleColumns, crosswalksMap, attributes, activeSurvivorshipGroupUri)
+            : [];
+    }, [
+        metadata,
+        parentTypeUri,
+        selectedAttributeTypes,
+        visibleColumns,
+        attributes,
+        crosswalksMap,
+        activeSurvivorshipGroupUri
+    ]);
+    var _l = useDynamicRowCellHeight(getRowCellKey), getDynamicRowCellHeight = _l.getDynamicRowCellHeight, changeRowCellHeight = _l.changeRowCellHeight;
+    var renderRowCell = useCallback(function (props) { return React.createElement(CommonRowCellRenderer, __assign({ changeRowCellHeight: changeRowCellHeight }, props)); }, [changeRowCellHeight]);
+    var getRowCellHeight = useCallback(either(getDynamicRowCellHeight, always(DEFAULT_ROW_HEIGHT)), [
+        getDynamicRowCellHeight
+    ]);
+    var _m = useState(null), pendingDeletion = _m[0], setPendingDeletion = _m[1];
+    var _o = useState(null), pendingIgnoredEditing = _o[0], setPendingIgnoredEditing = _o[1];
+    var handleEdit = useCallback(function (event) {
+        event.attributeValue.ignored ? setPendingIgnoredEditing(event) : onEdit(event);
+    }, [onEdit, setPendingIgnoredEditing]);
+    var handleReorderAttributeTypes = useCallback(function (oldPosition, newPosition) {
+        onSelectAttributeTypes(move(oldPosition, newPosition, selectedAttributeTypes));
+    }, [onSelectAttributeTypes, selectedAttributeTypes]);
+    var handleDelete = useCallback(pendingDeletion ? function () { return onDelete(pendingDeletion); } : noop, [
+        pendingDeletion,
+        onDelete
+    ]);
+    var tableContext = useMemo(function () { return ({
+        onDelete: setPendingDeletion,
+        onPin: onPin,
+        onIgnore: onIgnore,
+        onEdit: handleEdit,
+        onAdd: onAdd,
+        parentUri: parentUri,
+        parentTypeUri: parentTypeUri,
+        selectedAttributeTypes: selectedAttributeTypes,
+        onSelectAttributeTypes: onSelectAttributeTypes,
+        emptyTempAttributeUris: emptyTempAttributeUris,
+        readOnly: readOnly
+    }); }, [
+        setPendingDeletion,
+        onPin,
+        onIgnore,
+        handleEdit,
+        onAdd,
+        parentUri,
+        parentTypeUri,
+        selectedAttributeTypes,
+        onSelectAttributeTypes,
+        emptyTempAttributeUris,
+        readOnly
+    ]);
+    return (React.createElement("div", { className: classnames(styles.tableContainer, className) },
+        React.createElement(BasicViewHeader, { classes: { root: styles.tableHeader, title: styles.tableTitle }, title: i18n.text('Sources') },
+            additionalHeaderItems,
+            React.createElement(ColumnsSettings, { columnsData: COLUMNS_DATA, selectedColumns: visibleColumns, onChangeColumns: onChangeVisibleColumns })),
+        React.createElement("div", { className: styles.tableContent },
+            isLoading && React.createElement(LinearLoadIndicator, null),
+            React.createElement(BasicTable, { fixFirstColumn: true, headRowHeight: 48, defaultColumnWidth: 250, defaultColumnMinWidth: 200, columnsData: visibleColumnsData, dndRowReorderingEnabled: false, dndRowReorderingHandler: handleReorderAttributeTypes, getIdFromRowValue: getIdFromRowValue, rowsData: rowsData, renderRowCell: renderRowCell, getRowCellHeight: getRowCellHeight, context: tableContext })),
+        React.createElement(ConfirmDeleteDialog, { open: !!pendingDeletion, onClose: function () { return setPendingDeletion(null); }, onConfirm: handleDelete }),
+        React.createElement(ConfirmEditIgnoredDialog, { open: !!pendingIgnoredEditing, onClose: function () { return setPendingIgnoredEditing(null); }, onConfirmEditWithIgnore: function () { return pendingIgnoredEditing && onEdit(pendingIgnoredEditing); }, onConfirmEditWithoutIgnore: function () {
+                pendingIgnoredEditing && onEdit(__assign(__assign({}, pendingIgnoredEditing), { clearAttributeFlags: true }));
+            } })));
+};
+export default memo(AttributesTable);

package/esm/features/crosswalks/AttributesTable/AttributesTable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/features/crosswalks/AttributesTable/AttributesTable.test.js

@@ -0,0 +1,402 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React from 'react';
+import { mount, shallow } from 'enzyme';
+import { act } from 'react-dom/test-utils';
+import i18n from 'ui-i18n';
+import Button from '@mui/material/Button';
+import { BasicTable } from '../../../BasicTable';
+import { ColumnsSettings } from '../../../ColumnsSettings';
+import { BasicViewHeader } from '../../../BasicViewHeader';
+import LinearLoadIndicator from '../../../components/LinearLoadIndicator/LinearLoadIndicator';
+import { EmptyStub } from '../../../core';
+import { useMdmMetadata } from '../../../contexts/MdmModuleContext';
+import * as helpers from './helpers';
+import { COLUMNS_DATA, DEFAULT_VISIBLE_COLUMNS } from './helpers';
+import { AttributesFactory } from './components/AttributesFactory';
+import { OvValuesRenderer } from './components/OvValuesRenderer';
+import { RuleTypeRenderer } from './components/RuleTypeRenderer';
+import { ConfirmEditIgnoredDialog } from './components/ConfirmEditIgnoredDialog';
+import AttributesTable from './AttributesTable';
+jest.mock('react-virtualized-auto-sizer', function () {
+    return jest.fn().mockImplementation(function (_a) {
+        var children = _a.children;
+        return React.createElement("div", null, children());
+    });
+});
+jest.mock('./components/OvValuesRenderer', function () { return ({
+    OvValuesRenderer: jest.fn()
+}); });
+jest.mock('./components/RuleTypeRenderer', function () { return ({
+    RuleTypeRenderer: jest.fn()
+}); });
+jest.mock('./components/ConfirmEditIgnoredDialog', function () { return ({
+    ConfirmEditIgnoredDialog: jest.fn()
+}); });
+jest.mock('../../../contexts/MdmModuleContext', function () { return (__assign(__assign({}, jest.requireActual('../../../contexts/MdmModuleContext')), { useMdmMetadata: jest.fn() })); });
+describe('AttributesTable tests', function () {
+    var metadata = {
+        entityTypes: [
+            {
+                uri: 'configuration/entityTypes/HCP',
+                label: 'HCP',
+                attributes: [
+                    {
+                        label: 'Country Code',
+                        name: 'CountryCode',
+                        type: 'String',
+                        uri: 'configuration/entityTypes/HCP/attributes/CountryCode'
+                    },
+                    {
+                        label: 'Date',
+                        name: 'Date',
+                        type: 'Date',
+                        uri: 'configuration/entityTypes/HCP/attributes/Date'
+                    },
+                    {
+                        label: 'Affiliated with',
+                        name: 'affiliatedwith',
+                        type: 'String',
+                        uri: 'configuration/entityTypes/HCP/attributes/affiliatedwith',
+                        hidden: true
+                    }
+                ]
+            }
+        ]
+    };
+    var props = {
+        entity: {
+            attributes: {
+                FirstName: [
+                    {
+                        uri: 'entities/1/attributes/FirstName/1',
+                        type: 'configuration/entityTypes/HCP/attributes/FirstName',
+                        ov: true,
+                        value: '90909'
+                    }
+                ],
+                CountryCode: [
+                    {
+                        uri: 'entities/1/attributes/CountryCode/1',
+                        type: 'configuration/entityTypes/HCP/attributes/CountryCode',
+                        value: 'Italy',
+                        lookupCode: 'IT',
+                        ov: true
+                    }
+                ],
+                Date: [
+                    {
+                        uri: 'entities/1/attributes/Date/1',
+                        type: 'configuration/entityTypes/HCP/attributes/Date',
+                        value: '123456',
+                        ov: false
+                    }
+                ],
+                affiliatedwith: [
+                    {
+                        uri: 'entities/1/attributes/affiliatedWith/1',
+                        type: 'configuration/entityTypes/HCP/attributes/affiliatedwith',
+                        value: 'value',
+                        ov: true
+                    }
+                ],
+                paging: {
+                    'configuration/entityTypes/HCP/attributes/affiliatedwith': {
+                        totalValues: 6,
+                        totalOvValues: 1
+                    }
+                }
+            },
+            type: 'configuration/entityTypes/HCP',
+            uri: 'entities/1'
+        },
+        crosswalksMap: {
+            entity: {},
+            relation: {}
+        },
+        isLoading: false,
+        onChangeVisibleColumns: jest.fn(),
+        onDelete: jest.fn(),
+        onPin: jest.fn(),
+        onIgnore: jest.fn(),
+        onEdit: jest.fn(),
+        onAdd: jest.fn(),
+        selectedAttributeTypes: [
+            {
+                label: 'Country Code',
+                name: 'CountryCode',
+                type: 'String',
+                uri: 'configuration/entityTypes/HCP/attributes/CountryCode'
+            },
+            {
+                label: 'Date',
+                name: 'Date',
+                type: 'Date',
+                uri: 'configuration/entityTypes/HCP/attributes/Date'
+            }
+        ],
+        activeSurvivorshipGroupUri: 'activeSurvivorshipGroupUri',
+        onSelectAttributeTypes: jest.fn(),
+        emptyTempAttributeUris: []
+    };
+    var COLUMNS_DATA_MOCK = [
+        { id: '1', label: 'col 1' },
+        { id: '2', label: 'col 2' }
+    ];
+    var ROWS_DATA_MOCK = [{ 1: 'col 1 row 1', 2: 'col 2 row 2' }];
+    beforeAll(function () {
+        useMdmMetadata.mockReturnValue(metadata);
+        OvValuesRenderer.mockImplementation(EmptyStub);
+        RuleTypeRenderer.mockImplementation(EmptyStub);
+        ConfirmEditIgnoredDialog.mockImplementation(EmptyStub);
+        jest.spyOn(AttributesFactory, 'build').mockReturnValue(null);
+    });
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should render basic table correctly', function () {
+        jest.spyOn(helpers, 'getBasicTableColumnsData').mockReturnValueOnce(COLUMNS_DATA_MOCK);
+        jest.spyOn(helpers, 'getBasicTableRowsData').mockReturnValueOnce(ROWS_DATA_MOCK);
+        var wrapper = shallow(React.createElement(AttributesTable, __assign({}, props)));
+        expect(wrapper.find(BasicTable).props()).toMatchObject({
+            fixFirstColumn: true,
+            rowsData: ROWS_DATA_MOCK,
+            columnsData: COLUMNS_DATA_MOCK
+        });
+        expect(helpers.getBasicTableRowsData).toBeCalledWith(metadata, 'configuration/entityTypes/HCP', props.selectedAttributeTypes, DEFAULT_VISIBLE_COLUMNS, props.crosswalksMap, props.entity.attributes, props.activeSurvivorshipGroupUri);
+        expect(helpers.getBasicTableColumnsData).toBeCalledWith(DEFAULT_VISIBLE_COLUMNS.map(function (columnId) { return COLUMNS_DATA.find(function (_a) {
+            var id = _a.id;
+            return id === columnId;
+        }); }));
+        expect(wrapper.find(BasicViewHeader).prop('title')).toBe(i18n.text('Sources'));
+    });
+    it('should show linear loader correctly', function () {
+        var wrapper = shallow(React.createElement(AttributesTable, __assign({}, props, { isLoading: false })));
+        expect(wrapper.find(LinearLoadIndicator).length).toBe(0);
+        wrapper.setProps({ isLoading: true });
+        expect(wrapper.find(LinearLoadIndicator).length).toBe(1);
+    });
+    it('should select initial attribute types when props.selectedAttributeTypes is nil', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        expect(props.onSelectAttributeTypes).not.toBeCalled();
+        wrapper.setProps({ selectedAttributeTypes: undefined });
+        expect(props.onSelectAttributeTypes).toBeCalledTimes(1);
+        expect(props.onSelectAttributeTypes).toBeCalledWith([
+            {
+                label: 'Country Code',
+                name: 'CountryCode',
+                type: 'String',
+                uri: 'configuration/entityTypes/HCP/attributes/CountryCode'
+            },
+            {
+                label: 'Date',
+                name: 'Date',
+                type: 'Date',
+                uri: 'configuration/entityTypes/HCP/attributes/Date'
+            }
+        ]);
+    });
+    it('should not render rows if entity is undefined', function () {
+        var wrapper = shallow(React.createElement(AttributesTable, __assign({}, props, { entity: undefined })));
+        expect(wrapper.find(BasicTable).prop('rowsData')).toEqual([]);
+    });
+    it('should render ColumnsSettings in the header and change columns correctly', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var columnsSettings = wrapper.find(ColumnsSettings);
+        expect(columnsSettings.prop('selectedColumns')).toEqual(DEFAULT_VISIBLE_COLUMNS);
+        expect(columnsSettings.prop('columnsData')).toEqual(COLUMNS_DATA);
+        var nextVisibleColumns = DEFAULT_VISIBLE_COLUMNS.slice(0, -1);
+        act(function () {
+            columnsSettings.prop('onChangeColumns')(nextVisibleColumns);
+        });
+        expect(props.onChangeVisibleColumns).toHaveBeenCalledWith(nextVisibleColumns);
+        wrapper.setProps({ visibleColumns: nextVisibleColumns });
+        expect(wrapper.find(ColumnsSettings).prop('selectedColumns')).toEqual(nextVisibleColumns);
+        expect(wrapper
+            .find(BasicTable)
+            .prop('columnsData')
+            .map(function (_a) {
+            var id = _a.id;
+            return id;
+        })).toEqual(nextVisibleColumns);
+    });
+    it('should pass props.onPin to AttributeValuesRenderer', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var onPin = wrapper.find('AttributeValuesRenderer').at(0).prop('onPin');
+        expect(onPin).toBe(props.onPin);
+    });
+    it('should pass props.onIgnore to AttributeValuesRenderer', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var onIgnore = wrapper.find('AttributeValuesRenderer').at(0).prop('onIgnore');
+        expect(onIgnore).toBe(props.onIgnore);
+    });
+    it('should call props.onDelete after confirmation on attribute delete', function () {
+        var _a, _b;
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        expect(wrapper.find('ConfirmDeleteDialog').prop('open')).toBe(false);
+        var onDelete = wrapper.find('AttributeValuesRenderer').at(0).prop('onDelete');
+        var deleteEvent = {
+            attributeValue: (_b = (_a = props.entity) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b['CountryCode'][0],
+            attributeType: metadata.entityTypes[0].attributes[0],
+            crosswalks: []
+        };
+        act(function () {
+            onDelete(deleteEvent);
+        });
+        wrapper.update();
+        expect(wrapper.find('ConfirmDeleteDialog').prop('open')).toBe(true);
+        act(function () {
+            wrapper
+                .find('ConfirmDeleteDialog')
+                .find(Button)
+                .filterWhere(function (button) { return button.text() === 'Yes'; })
+                .find('button')
+                .simulate('click');
+        });
+        wrapper.update();
+        expect(wrapper.find('ConfirmDeleteDialog').prop('open')).toBe(false);
+        expect(props.onDelete).toBeCalledWith(deleteEvent);
+    });
+    it('should not call props.onDelete without confirmation on attribute delete', function () {
+        var _a, _b;
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        expect(wrapper.find('ConfirmDeleteDialog').prop('open')).toBe(false);
+        var onDelete = wrapper.find('AttributeValuesRenderer').at(0).prop('onDelete');
+        var deleteEvent = {
+            attributeValue: (_b = (_a = props.entity) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b['CountryCode'][0],
+            attributeType: metadata.entityTypes[0].attributes[0],
+            crosswalks: []
+        };
+        act(function () {
+            onDelete(deleteEvent);
+        });
+        wrapper.update();
+        expect(wrapper.find('ConfirmDeleteDialog').prop('open')).toBe(true);
+        act(function () {
+            wrapper
+                .find('ConfirmDeleteDialog')
+                .find(Button)
+                .filterWhere(function (button) { return button.text() === 'No'; })
+                .find('button')
+                .simulate('click');
+        });
+        wrapper.update();
+        expect(wrapper.find('ConfirmDeleteDialog').prop('open')).toBe(false);
+        expect(props.onDelete).not.toBeCalled();
+    });
+    it('should call props.onEdit on not ignored attribute edit', function () {
+        var _a, _b;
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var onEdit = wrapper.find('AttributeValuesRenderer').at(0).prop('onEdit');
+        var editEvent = {
+            attributeValue: __assign(__assign({}, (_b = (_a = props.entity) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b['CountryCode'][0]), { value: 'Russisa', lookupCode: 'RU' }),
+            attributeType: metadata.entityTypes[0].attributes[0],
+            crosswalk: {
+                uri: 'entities/1/crosswalks/1',
+                type: 'configuration/sources/Reltio',
+                value: 'cw1'
+            }
+        };
+        act(function () {
+            onEdit(editEvent);
+        });
+        expect(props.onEdit).toBeCalledWith(editEvent);
+    });
+    it('should show confirmation dialog on ignored attribute edit', function () {
+        var _a, _b;
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        expect(wrapper.find(ConfirmEditIgnoredDialog).prop('open')).toBe(false);
+        var onEdit = wrapper.find('AttributeValuesRenderer').at(0).prop('onEdit');
+        var editEvent = {
+            attributeValue: __assign(__assign({}, (_b = (_a = props.entity) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b['CountryCode'][0]), { value: 'Russisa', lookupCode: 'RU', ignored: true }),
+            attributeType: metadata.entityTypes[0].attributes[0],
+            crosswalk: {
+                uri: 'entities/1/crosswalks/1',
+                type: 'configuration/sources/Reltio',
+                value: 'cw1'
+            }
+        };
+        act(function () {
+            onEdit(editEvent);
+        });
+        wrapper.update();
+        expect(props.onEdit).not.toBeCalled();
+        expect(wrapper.find(ConfirmEditIgnoredDialog).prop('open')).toBe(true);
+    });
+    it('should call props.onEdit if confirmed editing attribute with ignored ', function () {
+        var _a, _b;
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var onEdit = wrapper.find('AttributeValuesRenderer').at(0).prop('onEdit');
+        var editEvent = {
+            attributeValue: __assign(__assign({}, (_b = (_a = props.entity) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b['CountryCode'][0]), { value: 'Russisa', lookupCode: 'RU', ignored: true }),
+            attributeType: metadata.entityTypes[0].attributes[0],
+            crosswalk: {
+                uri: 'entities/1/crosswalks/1',
+                type: 'configuration/sources/Reltio',
+                value: 'cw1'
+            }
+        };
+        act(function () {
+            onEdit(editEvent);
+        });
+        wrapper.update();
+        wrapper.find(ConfirmEditIgnoredDialog).prop('onConfirmEditWithIgnore')();
+        expect(props.onEdit).toBeCalledWith(editEvent);
+        expect(props.onIgnore).not.toBeCalled();
+    });
+    it('should call props.onEdit and props.onIgnore if confirmed editing attribute without ignored ', function () {
+        var _a, _b;
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var onEdit = wrapper.find('AttributeValuesRenderer').at(0).prop('onEdit');
+        var editEvent = {
+            attributeValue: __assign(__assign({}, (_b = (_a = props.entity) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b['CountryCode'][0]), { value: 'Russisa', lookupCode: 'RU', ignored: true }),
+            attributeType: metadata.entityTypes[0].attributes[0],
+            crosswalk: {
+                uri: 'entities/1/crosswalks/1',
+                type: 'configuration/sources/Reltio',
+                value: 'cw1'
+            }
+        };
+        act(function () {
+            onEdit(editEvent);
+        });
+        wrapper.update();
+        wrapper.find(ConfirmEditIgnoredDialog).prop('onConfirmEditWithoutIgnore')();
+        expect(props.onEdit).toBeCalledWith(__assign(__assign({}, editEvent), { clearAttributeFlags: true }));
+        expect(props.onIgnore).not.toBeCalled();
+    });
+    it('should pass props.onAdd to AttributeValuesRenderer', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var onAdd = wrapper.find('AttributeValuesRenderer').at(0).prop('onAdd');
+        expect(onAdd).toBe(props.onAdd);
+    });
+    it('should pass entity uri to AttributeValuesRenderer', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var parentUri = wrapper.find('AttributeValuesRenderer').at(0).prop('parentUri');
+        expect(parentUri).toBe(props.entity.uri);
+    });
+    it('should pass correct props to AddAttributesButton', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props)));
+        var buttonProps = wrapper.find('AddAttributesButton').props();
+        expect(buttonProps).toEqual({
+            parentUri: props.entity.uri,
+            parentTypeUri: props.entity.type,
+            selectedAttributeTypes: props.selectedAttributeTypes,
+            onSelectAttributeTypes: props.onSelectAttributeTypes,
+            onAdd: props.onAdd
+        });
+    });
+    it('should pass correct props to AttributesHeadCellRenderer', function () {
+        var wrapper = mount(React.createElement(AttributesTable, __assign({}, props, { readOnly: true })));
+        expect(wrapper.find('AttributesHeadCellRenderer').prop('readOnly')).toBe(true);
+    });
+});

package/esm/features/crosswalks/AttributesTable/IntegrationAttributesTable.test-data.d.ts

@@ -0,0 +1,3 @@
+import { Entity, Metadata } from '@reltio/mdm-sdk';
+export declare const createEntity: () => Entity;
+export declare const createMetadata: () => Metadata;

package/esm/features/crosswalks/AttributesTable/IntegrationAttributesTable.test-data.js

@@ -0,0 +1,47 @@
+export var createEntity = function () {
+    return {
+        uri: 'entities/01L2n5z',
+        type: 'configuration/entityTypes/HCP',
+        label: 'entity label',
+        attributes: {
+            Boolean: [
+                {
+                    ov: true,
+                    type: 'configuration/entityTypes/HCP/attributes/Boolean',
+                    uri: 'entities/01L2n5z/attributes/Boolean/5nmc3Cp',
+                    value: 'true'
+                }
+            ],
+            TextField: [
+                {
+                    ov: true,
+                    type: 'configuration/entityTypes/HCP/attributes/TextField',
+                    uri: 'entities/01L2n5z/attributes/TextField/5noU1aB',
+                    value: 'text field value'
+                }
+            ]
+        },
+        crosswalks: [
+            {
+                attributes: [
+                    'entities/01L2n5z/attributes/TextField/5noU1aB',
+                    'entities/01L2n5z/attributes/Boolean/5nmc3Cp'
+                ],
+                type: 'configuration/sources/Reltio',
+                uri: 'entities/01L2n5z/crosswalks/7F10sMx',
+                value: '01L2n5z'
+            }
+        ]
+    };
+};
+export var createMetadata = function () {
+    return {
+        entityTypes: [],
+        sources: [
+            {
+                uri: 'configuration/sources/Reltio',
+                label: 'Reltio'
+            }
+        ]
+    };
+};

package/esm/features/crosswalks/AttributesTable/IntegrationAttributesTable.test.d.ts

@@ -0,0 +1 @@
+export {};