@reltio/profile 1.4.1585 → 1.4.1586-mui5

package/src/components/ProfileSingleAttributeView/__tests__/IntegrationProfileSingleAttribute.test.tsx

@@ -0,0 +1,368 @@
+import React, {ReactNode} from 'react';
+import {Provider} from 'react-redux';
+import {render, screen, waitFor, within} from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import {ActionsHookProvider} from '@reltio/components';
+import {profile} from '@reltio/mdm-module';
+import {
+    cascadeUpdate,
+    getDependentLookups,
+    getPagedEntity,
+    Mode,
+    ProfileViewTypes,
+    resolveLookupsList
+} from '@reltio/mdm-sdk';
+import {ProfileSingleAttributeView} from '../ProfileSingleAttributeView';
+import {createTestStore} from '../../../../../../__mocks__/store-utils';
+import {createInitialState} from './data/store.data';
+import {TestStylesProvider} from '../../../../../../test/TestStylesProvider';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getPagedEntity: jest.fn(),
+    getDependentLookups: jest.fn().mockResolvedValue({}),
+    cascadeUpdate: jest.fn((_, __) => Promise.resolve([])),
+    resolveLookupsList: jest.fn(),
+    typeAheadSearch: jest.fn().mockResolvedValue([])
+}));
+
+//eslint-disable-next-line
+jest.mock('@mui/material/Popper', () => ({children, open}) => {
+    return open ? <div role="tooltip">{children}</div> : null;
+});
+
+const defaultConfig = {
+    attributeUri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested',
+    max: 15,
+    id: 'Single attribute view',
+    class: ProfileViewTypes.SingleAttribute
+};
+
+describe('Profile Single Attribute view integration tests', () => {
+    let initialState, dispatch;
+
+    const setUp = (config = defaultConfig) => {
+        const user = userEvent.setup();
+        const store = createTestStore(initialState);
+        dispatch = store.dispatch;
+        const Providers = ({children}: {children: ReactNode}) => (
+            <Provider store={store}>
+                <TestStylesProvider>
+                    <ActionsHookProvider hook={() => () => {}}>{children}</ActionsHookProvider>
+                </TestStylesProvider>
+            </Provider>
+        );
+        return {...render(<ProfileSingleAttributeView config={config} />, {wrapper: Providers}), user, store};
+    };
+
+    beforeEach(() => {
+        initialState = createInitialState();
+        (getPagedEntity as jest.Mock).mockImplementation(() => Promise.resolve({}));
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('Viewing behavior', () => {
+        it('should render nested attribute correctly', async () => {
+            (getPagedEntity as jest.Mock).mockImplementation(() =>
+                Promise.resolve({
+                    attributes: {
+                        FirstLevelNested: [
+                            {
+                                label: 'Nested string 2 2',
+                                value: {
+                                    TextField: [
+                                        {
+                                            type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+                                            ov: true,
+                                            value: 'Nested string 2',
+                                            uri: 'entities/1rIaPEx4/attributes/FirstLevelNested/3PoAcCTob/FirstLevelNestedSub1/3PoAcCcL7'
+                                        }
+                                    ]
+                                },
+                                ov: true,
+                                uri: 'entities/1rIaPEx4/attributes/FirstLevelNested/3PoAcCTob'
+                            }
+                        ]
+                    }
+                })
+            );
+            initialState = createInitialState();
+            setUp();
+            const nestedValue = await screen.findByText('Nested string 2 2');
+            expect(nestedValue).toBeInTheDocument();
+        });
+
+        it('should render simple attribute correctly', async () => {
+            (getPagedEntity as jest.Mock).mockImplementation(() =>
+                Promise.resolve({
+                    attributes: {
+                        CountryCode: [
+                            {
+                                value: 'Germany',
+                                ov: true,
+                                uri: 'entities/1rIaPEx4/attributes/CountryCode/3u9VcI2Xw'
+                            }
+                        ]
+                    }
+                })
+            );
+            initialState = createInitialState();
+            const config = {
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/attributes/CountryCode'
+            };
+            setUp(config);
+            const simpleValue = await screen.findByText('Germany');
+            expect(simpleValue.closest('div')).toHaveClass('simpleAttribute');
+        });
+    });
+
+    describe('Editing behavior', () => {
+        describe('dependent lookups behaviour', () => {
+            it('should correctly perform cascadeUpdate for children dependent lookups after deleting whole required parent nested attribute', async () => {
+                const dependentLookupsChannel = {
+                    codeValues: {
+                        CHANNEL_NAME_CD: {
+                            FAX: {
+                                displayName: 'FAX',
+                                parents: ['CLASSIFICATION_NAME_CD.TELE']
+                            },
+                            EMAI: {
+                                displayName: 'Email',
+                                parents: ['CLASSIFICATION_NAME_CD.DIGI']
+                            }
+                        }
+                    }
+                };
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce(dependentLookupsChannel);
+                (getPagedEntity as jest.Mock).mockImplementation(() =>
+                    Promise.resolve({
+                        attributes: {
+                            ContactPreference: [
+                                {
+                                    label: 'Telephonic - Inherited FAX',
+                                    value: {
+                                        ChannelName: [
+                                            {
+                                                uri: 'entities/1rIaPEx4/attributes/ContactPreference/BasiCAn/ChannelName/BasiGR3',
+                                                ov: true,
+                                                type: 'configuration/entityTypes/HCP/attributes/ContactPreference/attributes/ChannelName',
+                                                value: 'Inherited FAX'
+                                            }
+                                        ],
+                                        ClassificationName: [
+                                            {
+                                                uri: 'entities/1rIaPEx4/attributes/ContactPreference/BasiCAn/ClassificationName/BasiKhJ',
+                                                ov: true,
+                                                type: 'configuration/entityTypes/HCP/attributes/ContactPreference/attributes/ClassificationName',
+                                                value: 'Telephonic'
+                                            }
+                                        ]
+                                    },
+                                    ov: true,
+                                    uri: 'entities/1rIaPEx4/attributes/ContactPreference/BasiCAn'
+                                }
+                            ]
+                        }
+                    })
+                );
+                initialState = createInitialState();
+                const config = {
+                    ...defaultConfig,
+                    attributeUri: 'configuration/entityTypes/HCP/attributes/ContactPreference'
+                };
+                const {user} = setUp(config);
+                await waitFor(() => Promise.resolve());
+                dispatch(profile.mode.actions.modeUpdated(Mode.Editing));
+                expect(screen.getByText('Telephonic - Inherited FAX')).toBeInTheDocument();
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce(dependentLookupsChannel);
+                await user.click(screen.getByTestId('reltio-delete-complex-attribute-button'));
+                expect(screen.queryByText('Telephonic (TELE)')).not.toBeInTheDocument();
+                const attribute = screen.getAllByTestId('reltio-attribute-value')[0];
+                await user.click(within(attribute).getByRole('textbox'));
+                (cascadeUpdate as jest.Mock).mockImplementationOnce((state, _) =>
+                    Promise.resolve([
+                        {
+                            uri: state[0].uri,
+                            type: 'configuration/entityTypes/HCP/attributes/ContactPreference/attributes/ChannelName',
+                            lookupValue: 'FAX',
+                            displayName: 'FAX',
+                            autopopulate: false,
+                            useDefaultValue: false
+                        },
+                        {
+                            uri: state[1].uri,
+                            type: 'configuration/entityTypes/HCP/attributes/ContactPreference/attributes/ClassificationName',
+                            lookupValue: 'TELE',
+                            displayName: 'Telephonic',
+                            autopopulate: true,
+                            useDefaultValue: true
+                        }
+                    ])
+                );
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce({
+                    codeValues: {
+                        CLASSIFICATION_NAME_CD: {
+                            TELE: {
+                                displayName: 'Telephonic',
+                                parents: ['CLASSIFICATION_NAME_CD.TELE']
+                            }
+                        }
+                    },
+                    parents: [
+                        {
+                            type: 'CHANNEL_NAME_CD',
+                            codeValues: ['FAX']
+                        }
+                    ]
+                });
+                const popup = screen.getByRole('tooltip');
+                await user.click(within(popup).getByText('FAX'));
+                expect(screen.getByText('Telephonic (TELE)')).toBeInTheDocument();
+            });
+
+            it('should correctly fill required dependent lookup with default value after deleting it', async () => {
+                const dependentLookupsCountries = {
+                    codeValues: {
+                        COUNTRY_CD: {
+                            DE: {displayName: 'Germany'},
+                            CN: {displayName: 'China'},
+                            PT: {displayName: 'Portugal'}
+                        }
+                    }
+                };
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce(dependentLookupsCountries);
+                (getPagedEntity as jest.Mock).mockImplementation(() =>
+                    Promise.resolve({
+                        attributes: {
+                            Test: [
+                                {
+                                    label: 'Portugal',
+                                    value: {
+                                        CountryCodeLookup: [
+                                            {
+                                                uri: 'entities/1rIaPEx4/attributes/Test/BasiCAn/CountryCodeLookup/BasiGR3',
+                                                ov: true,
+                                                type: 'configuration/entityTypes/HCP/attributes/Test/attributes/CountryCodeLookup',
+                                                value: 'Portugal',
+                                                lookupCode: 'PT',
+                                                lookupRawValue: 'PT'
+                                            }
+                                        ]
+                                    },
+                                    ov: true,
+                                    uri: 'entities/1rIaPEx4/attributes/Test/BasiCAn'
+                                }
+                            ]
+                        }
+                    })
+                );
+                (resolveLookupsList as jest.Mock).mockResolvedValue([
+                    {
+                        COUNTRY_CD: {PT: {displayName: 'Portugal'}}
+                    }
+                ]);
+                initialState = createInitialState();
+                const config = {
+                    ...defaultConfig,
+                    attributeUri: 'configuration/entityTypes/HCP/attributes/Test'
+                };
+                const {user, store} = setUp(config);
+                await waitFor(() => Promise.resolve());
+                dispatch(profile.mode.actions.modeUpdated(Mode.Editing));
+                await user.click(screen.getByTestId('arrow-expand-button'));
+                await user.click(screen.getByTestId('reltio-delete-simple-attribute-button'));
+                await screen.findByText('Portugal (PT)');
+                expect(
+                    store.getState().profile.modifiedEntities['entities/1rIaPEx4'].attributes['Test'][0].value[
+                        'CountryCodeLookup'
+                    ][0]
+                ).toMatchObject({
+                    value: 'Portugal',
+                    lookupCode: 'PT'
+                });
+            });
+
+            it('should correctly perform cascadeUpdate for children dependent lookups inside temp referenced entity', async () => {
+                const dependentLookupsResponse = {
+                    codeValues: {
+                        CHANNEL_NAME_CD: {
+                            FAX: {
+                                displayName: 'FAX',
+                                parents: ['CLASSIFICATION_NAME_CD.TELE']
+                            },
+                            EMAI: {
+                                displayName: 'Email',
+                                parents: ['CLASSIFICATION_NAME_CD.DIGI']
+                            }
+                        }
+                    }
+                };
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce(dependentLookupsResponse);
+                (getPagedEntity as jest.Mock).mockImplementation(() =>
+                    Promise.resolve({
+                        attributes: {
+                            HCPtoHCA: []
+                        }
+                    })
+                );
+                initialState = createInitialState({entityTypeUri: 'configuration/entityTypes/HCA'});
+                const config = {
+                    ...defaultConfig,
+                    attributeUri: 'configuration/entityTypes/HCA/attributes/HCPtoHCA'
+                };
+                const {user} = setUp(config);
+                await waitFor(() => Promise.resolve());
+                dispatch(profile.mode.actions.modeUpdated(Mode.Editing));
+                screen.getByText('Select HCP profile');
+                await user.click(screen.getByTestId('select-dropdown-indicator'));
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce(dependentLookupsResponse);
+                await user.click(await screen.findByText('Create new HCP'));
+                const attribute = screen.getAllByTestId('reltio-attribute-value')[0];
+                await user.click(within(attribute).getByRole('textbox'));
+                (cascadeUpdate as jest.Mock).mockImplementationOnce((state, _) =>
+                    Promise.resolve([
+                        {
+                            uri: state[0].uri,
+                            type: 'configuration/entityTypes/HCP/attributes/ContactPreference/attributes/ChannelName',
+                            lookupValue: 'FAX',
+                            displayName: 'FAX',
+                            autopopulate: false,
+                            useDefaultValue: false
+                        },
+                        {
+                            uri: state[1].uri,
+                            type: 'configuration/entityTypes/HCP/attributes/ContactPreference/attributes/ClassificationName',
+                            lookupValue: 'TELE',
+                            displayName: 'Telephonic',
+                            autopopulate: true,
+                            useDefaultValue: true
+                        }
+                    ])
+                );
+                (getDependentLookups as jest.Mock).mockResolvedValueOnce({
+                    codeValues: {
+                        CLASSIFICATION_NAME_CD: {
+                            TELE: {
+                                displayName: 'Telephonic',
+                                parents: ['CLASSIFICATION_NAME_CD.TELE']
+                            }
+                        }
+                    },
+                    parents: [
+                        {
+                            type: 'CHANNEL_NAME_CD',
+                            codeValues: ['FAX']
+                        }
+                    ]
+                });
+                const popup = screen.getByRole('tooltip');
+                await user.click(within(popup).getByText('FAX'));
+                expect(screen.getByText('Telephonic (TELE)')).toBeInTheDocument();
+            });
+        });
+    });
+});