@reltio/sources 1.4.1585 → 1.4.1586-mui5

package/src/components/UnmergeDialog/__tests__/testData.data.ts

@@ -0,0 +1,271 @@
+import {Contributor, CrosswalkTree} from '@reltio/mdm-sdk';
+
+export const contributors: Contributor[] = [
+    {
+        uri: 'entities/j8K1vc9',
+        crosswalks: [
+            {
+                uri: 'entities/j8K1vc9/crosswalks/1kQ5cap2n',
+                type: 'configuration/sources/Reltio',
+                ownerType: 'entity',
+                value: 'j8K1vc9'
+            },
+            {
+                uri: 'relations/fwqqZcE/crosswalks/3CQl2KAH8',
+                type: 'configuration/sources/Reltio',
+                ownerType: 'relation',
+                value: 'fwqqZcE'
+            }
+        ],
+        merges: [
+            {
+                losers: [
+                    {
+                        crosswalks: [
+                            {
+                                ownerType: 'entity',
+                                type: 'configuration/sources/MDS',
+                                uri: 'entities/j8K1vc9/crosswalks/3dPCbiK7u',
+                                value: 'mds_202108061617'
+                            }
+                        ],
+                        phantomEntity: true,
+                        uri: 'entities/1N1mfYja'
+                    }
+                ],
+                mergeReason: 'Merge on the fly',
+                mergeRules: '',
+                time: 1628248691969,
+                user: 'marat'
+            },
+            {
+                losers: [
+                    {
+                        merges: [
+                            {
+                                losers: [
+                                    {
+                                        crosswalks: [
+                                            {
+                                                ownerType: 'entity',
+                                                type: 'configuration/sources/DEA',
+                                                uri: 'entities/j8K1vc9/crosswalks/1CwTipUbG',
+                                                value: 'DEA'
+                                            }
+                                        ],
+                                        phantomEntity: true,
+                                        uri: 'entities/hBEvFzQ'
+                                    }
+                                ],
+                                mergeReason: 'Move phantoms from gDAOTUO due to S_1543928071633_0001GJf',
+                                mergeRules: '',
+                                time: 1543928071655,
+                                user: 'alexander.kirsanov'
+                            }
+                        ],
+                        uri: 'entities/p6u3cIz'
+                    }
+                ],
+                mergeReason: 'Merge by hand',
+                mergeRules: '',
+                time: 1543928125863,
+                user: 'alexander.kirsanov'
+            },
+            {
+                losers: [
+                    {
+                        crosswalks: [
+                            {
+                                ownerType: 'entity',
+                                type: 'configuration/sources/AHA',
+                                uri: 'entities/j8K1vc9/crosswalks/1vLQ8LtYf',
+                                value: 'AHA1'
+                            },
+                            {
+                                ownerType: 'entity',
+                                type: 'configuration/sources/Veeva',
+                                uri: 'entities/j8K1vc9/crosswalks/1vLQ8MVuz',
+                                value: 'Veeva1'
+                            },
+                            {
+                                ownerType: 'entity',
+                                type: 'configuration/sources/AOA',
+                                uri: 'entities/j8K1vc9/crosswalks/1vLQ8Mihl',
+                                value: 'AOA'
+                            },
+                            {
+                                ownerType: 'entity',
+                                type: 'configuration/sources/Reltio',
+                                uri: 'entities/j8K1vc9/crosswalks/1vLQ8NL45',
+                                value: 'gDAOTUO'
+                            },
+                            {
+                                ownerType: 'relation',
+                                type: 'configuration/sources/Reltio',
+                                uri: 'relations/YduMTVk/crosswalks/1WY5HTvm8',
+                                value: 'YduMTVk'
+                            }
+                        ],
+                        uri: 'entities/gDAOTUO'
+                    }
+                ],
+                mergeReason: 'Merge by hand',
+                mergeRules: '',
+                time: 1543928117165,
+                user: 'alexander.kirsanov'
+            }
+        ]
+    },
+    {
+        uri: 'entities/1N1mfYja',
+        crosswalks: [
+            {
+                uri: 'entities/j8K1vc9/crosswalks/3dPCbiK7u',
+                type: 'configuration/sources/MDS',
+                ownerType: 'entity',
+                value: 'mds_202108061617'
+            }
+        ]
+    },
+    {
+        crosswalks: undefined,
+        uri: 'entities/p6u3cIz',
+        merges: [
+            {
+                losers: [
+                    {
+                        crosswalks: [
+                            {
+                                ownerType: 'entity',
+                                type: 'configuration/sources/DEA',
+                                uri: 'entities/j8K1vc9/crosswalks/1CwTipUbG',
+                                value: 'DEA'
+                            }
+                        ],
+                        phantomEntity: true,
+                        uri: 'entities/hBEvFzQ'
+                    }
+                ],
+                mergeReason: 'Move phantoms from gDAOTUO due to S_1543928071633_0001GJf',
+                mergeRules: '',
+                time: 1543928071655,
+                user: 'alexander.kirsanov'
+            }
+        ]
+    }
+];
+export const crosswalkTree: CrosswalkTree = {
+    merges: [
+        {
+            time: 1628248691969,
+            mergeReason: 'Merge on the fly',
+            mergeRules: '',
+            user: 'marat',
+            losers: [
+                {
+                    uri: 'entities/1N1mfYja',
+                    crosswalks: [
+                        {
+                            uri: 'entities/j8K1vc9/crosswalks/3dPCbiK7u',
+                            type: 'configuration/sources/MDS',
+                            ownerType: 'entity',
+                            value: 'mds_202108061617'
+                        }
+                    ],
+                    phantomEntity: true
+                }
+            ]
+        },
+        {
+            time: 1543928125863,
+            mergeReason: 'Merge by hand',
+            mergeRules: '',
+            user: 'alexander.kirsanov',
+            losers: [
+                {
+                    merges: [
+                        {
+                            time: 1543928071655,
+                            mergeReason: 'Move phantoms from gDAOTUO due to S_1543928071633_0001GJf',
+                            mergeRules: '',
+                            user: 'alexander.kirsanov',
+                            losers: [
+                                {
+                                    uri: 'entities/hBEvFzQ',
+                                    crosswalks: [
+                                        {
+                                            uri: 'entities/j8K1vc9/crosswalks/1CwTipUbG',
+                                            type: 'configuration/sources/DEA',
+                                            ownerType: 'entity',
+                                            value: 'DEA'
+                                        }
+                                    ],
+                                    phantomEntity: true
+                                }
+                            ]
+                        }
+                    ],
+                    uri: 'entities/p6u3cIz'
+                }
+            ]
+        },
+        {
+            time: 1543928117165,
+            mergeReason: 'Merge by hand',
+            mergeRules: '',
+            user: 'alexander.kirsanov',
+            losers: [
+                {
+                    uri: 'entities/gDAOTUO',
+                    crosswalks: [
+                        {
+                            uri: 'entities/j8K1vc9/crosswalks/1vLQ8LtYf',
+                            type: 'configuration/sources/AHA',
+                            ownerType: 'entity',
+                            value: 'AHA1'
+                        },
+                        {
+                            uri: 'entities/j8K1vc9/crosswalks/1vLQ8MVuz',
+                            type: 'configuration/sources/Veeva',
+                            ownerType: 'entity',
+                            value: 'Veeva1'
+                        },
+                        {
+                            uri: 'entities/j8K1vc9/crosswalks/1vLQ8Mihl',
+                            type: 'configuration/sources/AOA',
+                            ownerType: 'entity',
+                            value: 'AOA'
+                        },
+                        {
+                            uri: 'entities/j8K1vc9/crosswalks/1vLQ8NL45',
+                            type: 'configuration/sources/Reltio',
+                            ownerType: 'entity',
+                            value: 'gDAOTUO'
+                        },
+                        {
+                            uri: 'relations/YduMTVk/crosswalks/1WY5HTvm8',
+                            type: 'configuration/sources/Reltio',
+                            ownerType: 'relation',
+                            value: 'YduMTVk'
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    uri: 'entities/j8K1vc9',
+    crosswalks: [
+        {
+            uri: 'entities/j8K1vc9/crosswalks/1kQ5cap2n',
+            type: 'configuration/sources/Reltio',
+            ownerType: 'entity',
+            value: 'j8K1vc9'
+        },
+        {
+            uri: 'relations/fwqqZcE/crosswalks/3CQl2KAH8',
+            type: 'configuration/sources/Reltio',
+            ownerType: 'relation',
+            value: 'fwqqZcE'
+        }
+    ]
+};

package/src/components/UnmergeDialog/styles.ts

@@ -0,0 +1,34 @@
+import {makeStyles} from '@mui/styles';
+
+export const useStyles = makeStyles((theme) => ({
+    dialogContainer: {
+        maxWidth: 'unset'
+    },
+    dialogTitle: {
+        padding: '13px 16px 0 16px',
+        fontWeight: 500,
+        fontSize: '20px',
+        lineHeight: '23px',
+        letterSpacing: '0.25px'
+    },
+    dialogContent: {
+        display: 'flex',
+        flexDirection: 'column',
+        padding: '13px 16px 0 16px'
+    },
+    trees: {
+        display: 'flex'
+    },
+    uri: {
+        fontSize: '13px',
+        lineHeight: '15px',
+        color: theme.palette.text.primary,
+        marginBottom: '15px'
+    },
+    title: {
+        fontSize: '13px',
+        lineHeight: '15px',
+        color: theme.palette.text.secondary,
+        paddingRight: '2px'
+    }
+}));

package/src/components/UnsubscribeDialog/UnsubscribeDialog.tsx

@@ -0,0 +1,64 @@
+import React, {useMemo} from 'react';
+import i18n from 'ui-i18n';
+import Button from '@mui/material/Button';
+import Dialog from '@mui/material/Dialog';
+import DialogActions from '@mui/material/DialogActions';
+import DialogContent from '@mui/material/DialogContent';
+import DialogTitle from '@mui/material/DialogTitle';
+import Typography from '@mui/material/Typography';
+import {SelectableTree} from '../SelectableTree/SelectableTree';
+import {collectCrosswalksFromContributor, Contributor, CrosswalkTree, getLastUriPart} from '@reltio/mdm-sdk';
+
+import {useStyles} from './styles';
+
+type Props = {
+    contributor: Contributor;
+    crosswalkTree: CrosswalkTree;
+    canUnsubscribe?: boolean;
+    onClose: () => void;
+    onUnsubscribeContributor: () => void;
+};
+
+export const UnsubscribeDialog = ({
+    canUnsubscribe,
+    contributor,
+    crosswalkTree,
+    onClose,
+    onUnsubscribeContributor
+}: Props) => {
+    const styles = useStyles();
+
+    const coloredCrosswalks = useMemo(
+        () => collectCrosswalksFromContributor(contributor, true).map(({uri}) => uri),
+        [contributor]
+    );
+
+    const unsubscribeContributor = () => {
+        onUnsubscribeContributor();
+        onClose();
+    };
+
+    return (
+        <Dialog open={true} onClose={onClose} classes={{paper: styles.dialogContainer}}>
+            <DialogTitle classes={{root: styles.dialogTitle}}>{i18n.text('Unsubscribe')}</DialogTitle>
+            <DialogContent classes={{root: styles.dialogContent}}>
+                <Typography variant={'body2'} className={styles.uri}>
+                    <span className={styles.title}>{i18n.text('Entity URI:')}</span>
+                    {getLastUriPart(contributor.uri).toUpperCase()}
+                </Typography>
+                <SelectableTree
+                    selected
+                    title={i18n.text('Unsubscribe')}
+                    crosswalkTree={crosswalkTree}
+                    coloredCrosswalks={coloredCrosswalks}
+                />
+            </DialogContent>
+            <DialogActions>
+                <Button onClick={onClose}>{i18n.text('Cancel')}</Button>
+                <Button disabled={!canUnsubscribe} onClick={unsubscribeContributor} color="primary">
+                    {i18n.text('Unsubscribe')}
+                </Button>
+            </DialogActions>
+        </Dialog>
+    );
+};

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

@@ -0,0 +1,59 @@
+import React from 'react';
+import {shallow} from 'enzyme';
+import Button from '@mui/material/Button';
+import {SelectableTree} from '../../SelectableTree/SelectableTree';
+import {contributors, crosswalkTree} from '../../UnmergeDialog/__tests__/testData.data';
+import {UnsubscribeDialog} from '../UnsubscribeDialog';
+import Typography from '@mui/material/Typography';
+
+describe('UnsubscribeDialog tests', () => {
+    const contributorUri = 'entities/p6u3cIz';
+    const props = {
+        contributor: contributors.find(({uri}) => uri === contributorUri),
+        crosswalkTree,
+        canUnsubscribe: true,
+        onClose: jest.fn(),
+        onUnsubscribeContributor: jest.fn()
+    };
+
+    it('should render correctly', () => {
+        const component = shallow(<UnsubscribeDialog {...props} />);
+        const selectableTree = component.find(SelectableTree);
+
+        expect(component.find(Typography).text()).toBe('Entity URI:P6U3CIZ');
+        expect(selectableTree.prop('selected')).toBe(true);
+        expect(selectableTree.prop('crosswalkTree')).toEqual(props.crosswalkTree);
+        expect(selectableTree.prop('coloredCrosswalks')).toEqual([]);
+        expect(selectableTree.prop('title')).toBe('Unsubscribe');
+        const unsubscribeButton = component.find(Button).filterWhere((button) => button.text() === 'Unsubscribe');
+        expect(unsubscribeButton.prop('disabled')).toBeFalsy();
+    });
+
+    it('should call onUnsubscribeContributor and onClose on Unsubscribe Button click', () => {
+        const component = shallow(<UnsubscribeDialog {...props} />);
+        const unsubscribeContributor = component
+            .find(Button)
+            .filterWhere((button) => button.text() === 'Unsubscribe')
+            .prop('onClick') as () => void;
+        unsubscribeContributor();
+        expect(props.onUnsubscribeContributor).toHaveBeenCalled();
+        expect(props.onClose).toHaveBeenCalled();
+    });
+
+    it('should call onClose on Cancel Button click', () => {
+        const component = shallow(<UnsubscribeDialog {...props} />);
+        const closeDialog = component
+            .find(Button)
+            .filterWhere((button) => button.text() === 'Cancel')
+            .prop('onClick') as () => void;
+        closeDialog();
+        expect(props.onClose).toHaveBeenCalled();
+    });
+
+    it('should disable unsubscribe button if canUnsubscribe === false', () => {
+        const component = shallow(<UnsubscribeDialog {...props} canUnsubscribe={false} />);
+
+        const unsubscribeButton = component.find(Button).filterWhere((button) => button.text() === 'Unsubscribe');
+        expect(unsubscribeButton.prop('disabled')).toBeTruthy();
+    });
+});

package/src/components/UnsubscribeDialog/styles.ts

@@ -0,0 +1,31 @@
+import {makeStyles} from '@mui/styles';
+
+export const useStyles = makeStyles((theme) => ({
+    dialogContainer: {
+        maxWidth: 'unset'
+    },
+    dialogTitle: {
+        padding: '13px 16px 0 16px',
+        fontWeight: 500,
+        fontSize: '20px',
+        lineHeight: '23px',
+        letterSpacing: '0.25px'
+    },
+    dialogContent: {
+        display: 'flex',
+        flexDirection: 'column',
+        padding: '13px 16px 0 16px'
+    },
+    uri: {
+        fontSize: '13px',
+        lineHeight: '15px',
+        color: theme.palette.text.primary,
+        marginBottom: '15px'
+    },
+    title: {
+        fontSize: '13px',
+        lineHeight: '15px',
+        color: theme.palette.text.secondary,
+        paddingRight: '2px'
+    }
+}));

package/src/hooks/__tests__/useCrosswalkTree.specs.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import {mount} from 'enzyme';
+import {act} from 'react-dom/test-utils';
+import * as mdmSdk from '@reltio/mdm-sdk';
+import {useCrosswalkTree} from '../useCrosswalkTree';
+import {noop} from '@reltio/components';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getCrosswalkTree: jest.fn()
+}));
+
+type Props = {
+    entity?: {uri: string};
+    onSuccess?: () => void;
+};
+
+describe('useCrosswalkTree behaviour', () => {
+    const getCrosswalkTreeSpy = jest.spyOn(mdmSdk, 'getCrosswalkTree');
+    const TestComponent = ({entity, onSuccess = noop}: Props) => {
+        const {crosswalkTree, reload} = useCrosswalkTree({onSuccess, entityUri: entity?.uri});
+        return <div data-test={{crosswalkTree}} onClick={reload} />;
+    };
+
+    beforeAll(() => {
+        getCrosswalkTreeSpy.mockImplementation(() => Promise.resolve({uri: 'testUri'}));
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should call getCrosswalkTree', async () => {
+        await act(async () => {
+            mount(<TestComponent entity={{uri: '123'}} />);
+        });
+        expect(getCrosswalkTreeSpy).toBeCalledWith({
+            entityUri: '123'
+        });
+    });
+
+    it('should not call getCrosswalkTree if entity is Nil', async () => {
+        await act(async () => {
+            mount(<TestComponent entity={null} />);
+        });
+        expect(getCrosswalkTreeSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call getCrosswalkTree if reload is called', async () => {
+        let wrapper;
+        await act(async () => {
+            wrapper = mount(<TestComponent entity={{uri: '123'}} />);
+        });
+        const event = {} as React.MouseEvent<Document>;
+        await act(async () => {
+            wrapper.find('div').prop('onClick')(event);
+        });
+        expect(getCrosswalkTreeSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should call onRequestFinished', async () => {
+        const onSuccess = jest.fn();
+        await act(async () => {
+            mount(<TestComponent entity={{uri: '123'}} onSuccess={onSuccess} />);
+        });
+        expect(onSuccess).toBeCalled();
+    });
+});

package/src/hooks/__tests__/useCrosswalkTreeActions.specs.ts

@@ -0,0 +1,110 @@
+import {useCrosswalkTreeActions} from '../useCrosswalkTreeActions';
+import {act} from 'react-dom/test-utils';
+import * as reactRedux from 'react-redux';
+import mdmModule from '@reltio/mdm-module';
+import {renderHook} from '@testing-library/react-hooks';
+import * as mdmSdk from '@reltio/mdm-sdk';
+import {UnmergeOperation} from '@reltio/mdm-sdk';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    unmergeContributor: jest.fn(),
+    unsubscribeEntityFromDataTenantEntity: jest.fn()
+}));
+
+describe('useCrosswalkTreeActions', () => {
+    beforeAll(() => {
+        jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector({}));
+        jest.spyOn(mdmModule.selectors, 'getDtssPath').mockReturnValue('dtssPath/');
+        jest.spyOn(mdmModule.selectors, 'getTenant').mockReturnValue('test');
+    });
+    const initialProps = {
+        onSuccess: jest.fn(),
+        onError: jest.fn(),
+        onShowMessage: jest.fn()
+    };
+    const getActions = () => {
+        return renderHook(useCrosswalkTreeActions, {initialProps}).result.current;
+    };
+    let resolveSuccess, resolveError;
+
+    const entity = {
+        uri: 'entities/123',
+        type: 'configuration/entityTypes/HCP'
+    };
+
+    const unmergeResponse = {a: entity, b: entity};
+    const unmergeContributorMock = jest.spyOn(mdmSdk, 'unmergeContributor').mockImplementation(() => {
+        return new Promise((_resolve, _reject) => {
+            resolveSuccess = () => _resolve(unmergeResponse);
+            resolveError = () => _reject({});
+        });
+    });
+
+    const unsubscribeContributorMock = jest
+        .spyOn(mdmSdk, 'unsubscribeEntityFromDataTenantEntity')
+        .mockImplementation(() => {
+            return new Promise((_resolve, _reject) => {
+                resolveSuccess = () => _resolve({index: 0, object: {status: 'success'}, successful: true});
+                resolveError = () => _reject({error: 'Operation failed with error', successful: false});
+            });
+        });
+
+    it('should return correct unmergeContributor action and show message', async () => {
+        jest.clearAllMocks();
+        const {unmergeContributor} = getActions();
+        const unmergeEvent = {
+            contributorUri: '541',
+            entityUri: '123',
+            operationType: UnmergeOperation.TreeUnmerge
+        };
+        unmergeContributor(unmergeEvent);
+        expect(unmergeContributorMock).toBeCalledWith(unmergeEvent);
+        await act(async () => {
+            resolveSuccess();
+        });
+        expect(initialProps.onShowMessage).toBeCalledWith('has been unmerged', unmergeResponse.b);
+        expect(initialProps.onSuccess).toBeCalled();
+
+        unmergeContributor(unmergeEvent);
+        expect(unmergeContributorMock).toBeCalledWith(unmergeEvent);
+        await act(async () => {
+            resolveError();
+        });
+        expect(initialProps.onError).toBeCalledWith({});
+    });
+
+    it('should return correct unsubscribe Contributor action', async () => {
+        const {unsubscribeContributor} = getActions();
+        const unsubscribeEvent = {
+            dataTenant: {id: '1111123', label: '2222', name: '111'},
+            crosswalk: {uri: '370iIXrRf', type: '1231', value: '12312'}
+        };
+        unsubscribeContributor(unsubscribeEvent);
+
+        expect(unsubscribeContributorMock).toBeCalledWith({
+            customerTenant: 'test',
+            dataTenant: '1111123',
+            dtssPath: 'dtssPath/',
+            type: '1231',
+            value: '12312'
+        });
+        await act(async () => {
+            resolveSuccess();
+        });
+        expect(initialProps.onSuccess).toBeCalled();
+
+        unsubscribeContributor(unsubscribeEvent);
+        expect(unsubscribeContributorMock).toBeCalledWith({
+            customerTenant: 'test',
+            dataTenant: '1111123',
+            dtssPath: 'dtssPath/',
+            type: '1231',
+            value: '12312'
+        });
+        await act(async () => {
+            resolveError();
+        });
+        expect(initialProps.onError).toBeCalledWith({error: 'Operation failed with error', successful: false});
+    });
+});