@reltio/sources 1.4.1585 → 1.4.1586-mui5

package/src/components/LegendTable/__tests__/LegendTable.test.tsx

@@ -0,0 +1,273 @@
+import React from 'react';
+import {shallow, mount} from 'enzyme';
+import {act} from 'react-dom/test-utils';
+
+import LegendTable from '../LegendTable';
+import * as LegendTableRowImport from '../LegendTableRow/LegendTableRow';
+import LegendTableRow from '../LegendTableRow/LegendTableRow';
+import * as helpers from '../helpers';
+import {EmptyStub} from '@reltio/components';
+import {MetadataPermissions} from '@reltio/mdm-sdk';
+
+describe('LegendTable tests', () => {
+    const entityType = {
+        uri: 'configuration/entityTypes/HCP',
+        label: 'Label',
+        attributes: [],
+        type: 'testType'
+    };
+    const props = {
+        entity: {uri: 'entities/1', label: 'Label', type: 'configuration/entityTypes/HCP'},
+        entityType: entityType,
+        disableUnmerge: false,
+        canUnmerge: true,
+        contributors: [{uri: 'tree', crosswalks: []}],
+        selectedAttributeTypes: [
+            {
+                uri: 'configuration/entityTypes/HCP/attributes/Int',
+                type: 'Int',
+                label: 'Integer',
+                name: 'Int'
+            }
+        ],
+        onChangeVisibleCrosswalks: jest.fn(),
+        onAddCrosswalk: jest.fn(),
+        onEditCrosswalk: jest.fn(),
+        onDeleteCrosswalk: jest.fn(),
+        onUnmergeContributor: jest.fn(),
+        onUnsubscribeContributor: jest.fn()
+    };
+    const tableRowsDataMock = [
+        {
+            contributorUri: 'entities/2',
+            crosswalksBySources: [
+                {
+                    source: 'configuration/sources/Reltio',
+                    crosswalksByTypes: {
+                        empty: [],
+                        simple: [
+                            {
+                                uri: 'entities/2/crosswalks/1',
+                                value: '123',
+                                type: 'configuration/sources/Reltio'
+                            }
+                        ],
+                        dependent: []
+                    }
+                }
+            ]
+        },
+        {
+            contributorUri: 'entities/3',
+            crosswalksBySources: [
+                {
+                    source: 'configuration/sources/FB',
+                    crosswalksByTypes: {
+                        empty: [],
+                        simple: [],
+                        dependent: [
+                            {
+                                uri: 'entities/3/crosswalks/1',
+                                value: '456',
+                                type: 'configuration/sources/FB'
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+    ];
+
+    beforeAll(() => {
+        jest.spyOn(helpers, 'buildTableRowsData').mockReturnValue(tableRowsDataMock);
+        jest.spyOn(LegendTableRowImport, 'default').mockImplementation(EmptyStub);
+    });
+
+    it('should render correctly', () => {
+        const wrapper = shallow(<LegendTable {...props} />);
+        const rows = wrapper.find(LegendTableRow);
+        expect(rows.length).toBe(2);
+        rows.forEach((row, index) => {
+            expect(row.props()).toMatchObject({
+                canUnmerge: true,
+                contributorUri: tableRowsDataMock[index].contributorUri,
+                crosswalksBySources: tableRowsDataMock[index].crosswalksBySources,
+                disableAddCrosswalk: false,
+                disableEditCrosswalk: false,
+                disableDeleteCrosswalk: false,
+                onUnsubscribeContributor: props.onUnsubscribeContributor,
+                disableUnmergeContributor: false
+            });
+        });
+    });
+
+    it('should disable rows editing if props.readOnly is true', () => {
+        const wrapper = shallow(<LegendTable {...props} readOnly />);
+        wrapper.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableAddCrosswalk')).toBeTruthy();
+            expect(row.prop('disableEditCrosswalk')).toBeTruthy();
+            expect(row.prop('disableDeleteCrosswalk')).toBeTruthy();
+        });
+    });
+
+    it('should render LegendTableRow with proper disableAddCrosswalk prop', () => {
+        const noAddPermissionType = {
+            ...entityType,
+            access: [MetadataPermissions.READ]
+        };
+        const wrapperNoAddPermission = shallow(<LegendTable {...props} entityType={noAddPermissionType} />);
+        wrapperNoAddPermission.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableAddCrosswalk')).toBeTruthy();
+        });
+
+        const haveAddPermissionType = {
+            ...entityType,
+            access: [MetadataPermissions.UPDATE, MetadataPermissions.READ, MetadataPermissions.CREATE]
+        };
+        const wrapperAddPermission = shallow(<LegendTable {...props} entityType={haveAddPermissionType} />);
+        wrapperAddPermission.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableAddCrosswalk')).toBeFalsy();
+        });
+    });
+
+    it('should render LegendTableRow with proper disableEditCrosswalk prop', () => {
+        const noEditPermissionType = {
+            ...entityType,
+            access: [MetadataPermissions.READ]
+        };
+        const wrapperNoEditPermission = shallow(<LegendTable {...props} entityType={noEditPermissionType} />);
+        wrapperNoEditPermission.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableEditCrosswalk')).toBeTruthy();
+        });
+
+        const haveEditPermissionType = {
+            ...entityType,
+            access: [MetadataPermissions.UPDATE, MetadataPermissions.READ]
+        };
+        const wrapperEditPermission = shallow(<LegendTable {...props} entityType={haveEditPermissionType} />);
+        wrapperEditPermission.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableEditCrosswalk')).toBeFalsy();
+        });
+    });
+
+    it('should render LegendTableRow with proper disableDeleteCrosswalk prop', () => {
+        const noDeletePermissionType = {
+            ...entityType,
+            access: [MetadataPermissions.READ]
+        };
+        const wrapperNoDeletePermission = shallow(<LegendTable {...props} entityType={noDeletePermissionType} />);
+        wrapperNoDeletePermission.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableDeleteCrosswalk')).toBeTruthy();
+        });
+
+        const haveDeletePermissionType = {
+            ...entityType,
+            access: [MetadataPermissions.DELETE, MetadataPermissions.UPDATE, MetadataPermissions.READ]
+        };
+        const wrapperDeletePermission = shallow(<LegendTable {...props} entityType={haveDeletePermissionType} />);
+        wrapperDeletePermission.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('disableDeleteCrosswalk')).toBeFalsy();
+        });
+    });
+
+    it('should call props.onAddCrosswalk on LegendTableRow "onAdd" prop calling', () => {
+        const wrapper = shallow(<LegendTable {...props} />);
+        const onAddProps = {
+            contributorCrosswalk: {
+                type: 'contributorCrosswalk type',
+                uri: 'contributorCrosswalk uri',
+                value: '123'
+            },
+            crosswalk: {
+                type: 'crosswalk type',
+                value: '456'
+            }
+        };
+        wrapper.find(LegendTableRow).at(0).prop('onAdd')(onAddProps);
+        expect(props.onAddCrosswalk).toHaveBeenCalledWith({
+            ...onAddProps,
+            entity: props.entity
+        });
+    });
+
+    it('should call props.onEditCrosswalk on LegendTableRow "onEdit" prop calling', () => {
+        const wrapper = shallow(<LegendTable {...props} />);
+        const onEditProps = {
+            crosswalkId: '370iIXrRf',
+            attributeName: 'deleteDate',
+            value: '1631905200000'
+        };
+        wrapper.find(LegendTableRow).at(0).prop('onEdit')(onEditProps);
+        expect(props.onEditCrosswalk).toHaveBeenCalledWith({...onEditProps, entityUri: props.entity.uri});
+    });
+
+    it('should call props.onDeleteCrosswalk on LegendTableRow "onDelete" prop calling', () => {
+        const wrapper = shallow(<LegendTable {...props} />);
+        wrapper.find(LegendTableRow).at(0).prop('onDelete')('123');
+        expect(props.onDeleteCrosswalk).toHaveBeenCalledWith({entityUri: props.entity.uri, crosswalkId: '123'});
+    });
+
+    it('should toggle expanded sources and call onChangeVisibleCrosswalks correctly', () => {
+        const wrapper = mount(<LegendTable {...props} />);
+        expect(props.onChangeVisibleCrosswalks).toBeCalledWith([
+            {
+                uri: 'entities/2/crosswalks/1',
+                value: '123',
+                type: 'configuration/sources/Reltio'
+            }
+        ]);
+        act(() => {
+            wrapper.find(LegendTableRow).at(1).prop('onToggleSourceExpanded')('configuration/sources/FB');
+        });
+        expect(props.onChangeVisibleCrosswalks).toBeCalledWith([
+            {
+                uri: 'entities/2/crosswalks/1',
+                value: '123',
+                type: 'configuration/sources/Reltio'
+            },
+            {
+                uri: 'entities/3/crosswalks/1',
+                value: '456',
+                type: 'configuration/sources/FB'
+            }
+        ]);
+    });
+
+    it('should accent contributor if props.accentContributors is true', () => {
+        const wrapper = shallow(<LegendTable {...props} accentContributors={true} />);
+        wrapper.find(LegendTableRow).forEach((row) => {
+            expect(row.prop('accentContributor')).toBe(true);
+        });
+    });
+
+    it('should call props.onUnmergeContributor on LegendTableRow "onUnmerge" prop calling', () => {
+        const wrapper = shallow(<LegendTable {...props} />);
+        wrapper.find(LegendTableRow).at(0).prop('onUnmerge')();
+        expect(props.onUnmergeContributor).toHaveBeenCalledWith(tableRowsDataMock[0].contributorUri);
+    });
+
+    it('should call props.onUnsubscribeContributor on LegendTableRow "onUnsubscribeContributor" prop calling', () => {
+        const wrapper = shallow(<LegendTable {...props} />);
+        const unsubscribeEvent = {
+            contributorUri: 'cUri1',
+            dataTenant: {id: 'id1', label: 'label1', name: 'name1'},
+            crosswalk: {uri: 'crUri1', type: 'type1', value: 'value1'}
+        };
+        wrapper.find(LegendTableRow).at(0).prop('onUnsubscribeContributor')(unsubscribeEvent);
+        expect(props.onUnsubscribeContributor).toHaveBeenCalledWith(unsubscribeEvent);
+    });
+
+    it('should provide disableUnmergeContributor === true, if disableUnmerge prop is true', () => {
+        const wrapper = shallow(<LegendTable {...props} disableUnmerge={true} />);
+        const rows = wrapper.find(LegendTableRow);
+        expect(rows.length).toBe(2);
+        rows.forEach((row, index) => {
+            expect(row.props()).toMatchObject({
+                contributorUri: tableRowsDataMock[index].contributorUri,
+                crosswalksBySources: tableRowsDataMock[index].crosswalksBySources,
+                onUnsubscribeContributor: props.onUnsubscribeContributor,
+                disableUnmergeContributor: true
+            });
+        });
+    });
+});