@reltio/profile 1.4.1585 → 1.4.1586-mui5

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

@@ -0,0 +1,744 @@
+import React from 'react';
+import * as reactRedux from 'react-redux';
+import {act} from 'react-dom/test-utils';
+import {mount} from 'enzyme';
+import {EmptyStub} from '@reltio/components';
+import {getPagedEntity, Mode, TableAttributeViewConfig} from '@reltio/mdm-sdk';
+import {profile} from '@reltio/mdm-module';
+import {TableAttributeView} from '../components/TableAttributeView/TableAttributeView';
+import {ProfileTableAttributeView} from '../ProfileTableAttributeView';
+import {TableAttributeContext} from '../contexts/TableAttributeContext';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...(jest.requireActual('@reltio/mdm-sdk') as Record<string, unknown>),
+    getPagedEntity: jest.fn().mockResolvedValue({})
+}));
+
+jest.mock('../components/TableAttributeView/TableAttributeView', () => ({
+    TableAttributeView: jest.fn()
+}));
+
+jest.mock('../contexts/TableAttributeContext', () => ({
+    TableAttributeContext: {
+        Provider: jest.fn()
+    }
+}));
+
+const createStore = (attributeHidden = false, mode = Mode.Viewing) => {
+    const tenant = 'knest';
+
+    return {
+        metadata: {
+            [tenant]: {
+                uri: 'configuration',
+                entityTypes: [
+                    {
+                        uri: 'configuration/entityTypes/HCP',
+                        attributes: [
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested',
+                                name: 'FirstLevelNested',
+                                ...(attributeHidden ? {hidden: true} : {}),
+                                attributes: [
+                                    {
+                                        label: 'FirstLevelNestedSub1_HCP',
+                                        name: 'FirstLevelNestedSub1',
+                                        uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+                                        dependentLookupCode: 'LANG_CD',
+                                        searchable: true,
+                                        skipInDataAccess: false,
+                                        system: false,
+                                        type: 'String'
+                                    },
+                                    {
+                                        label: 'Date1_HCP',
+                                        name: 'Date1',
+                                        uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/Date1',
+                                        attributeOrdering: {orderType: 'ASC', orderingStrategy: 'LUD'},
+                                        skipInDataAccess: false,
+                                        system: false,
+                                        faceted: true,
+                                        hidden: false,
+                                        type: 'Date'
+                                    }
+                                ]
+                            },
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/Commenters',
+                                hidden: true
+                            },
+                            {
+                                label: 'Affiliated with',
+                                name: 'affiliatedwith',
+                                type: 'Reference',
+                                uri: 'configuration/entityTypes/HCP/attributes/affiliatedwith',
+                                referencedAttributeURIs: [
+                                    'configuration/entityTypes/Organization/attributes/Nick',
+                                    'configuration/entityTypes/Organization/attributes/Name',
+                                    'configuration/relationTypes/affiliatedwith/attributes/Title',
+                                    'configuration/relationTypes/affiliatedwith/attributes/Status'
+                                ],
+                                referencedEntityTypeURI: 'configuration/entityTypes/Organization',
+                                relationshipTypeURI: 'configuration/relationTypes/affiliatedwith'
+                            }
+                        ],
+                        analyticsAttributes: [
+                            {
+                                uri: 'configuration/entityTypes/HCP/analyticsAttributes/DQ',
+                                name: 'DQ',
+                                label: 'DQ',
+                                hidden: false
+                            }
+                        ]
+                    },
+                    {
+                        uri: 'configuration/entityTypes/Organization',
+                        label: 'Organization',
+                        dataLabelPattern: '{Name}!',
+                        attributes: [
+                            {
+                                label: 'Name',
+                                name: 'Name',
+                                type: 'String',
+                                uri: 'configuration/entityTypes/Organization/attributes/Name'
+                            },
+                            {
+                                label: 'oAuth Customer name',
+                                name: 'oAuthAccount',
+                                type: 'String',
+                                uri: 'configuration/entityTypes/Organization/attributes/oAuthAccount'
+                            },
+                            {
+                                label: 'Nickname',
+                                name: 'Nick',
+                                type: 'String',
+                                uri: 'configuration/entityTypes/Organization/attributes/Nick'
+                            }
+                        ]
+                    }
+                ],
+                relationTypes: [
+                    {
+                        uri: 'configuration/relationTypes/affiliatedwith',
+                        label: 'Affiliated with',
+                        attributes: [
+                            {
+                                label: 'Contact Type',
+                                name: 'ContactType',
+                                type: 'String',
+                                uri: 'configuration/relationTypes/affiliatedwith/attributes/ContactType',
+                                lookupCode: 'rdm/lookupTypes/ContactType_affiliatedwith'
+                            },
+                            {
+                                label: 'Title',
+                                name: 'Title',
+                                type: 'String',
+                                uri: 'configuration/relationTypes/affiliatedwith/attributes/Title'
+                            },
+                            {
+                                label: 'Status',
+                                name: 'Status',
+                                type: 'String',
+                                uri: 'configuration/relationTypes/affiliatedwith/attributes/Status',
+                                lookupCode: 'rdm/lookupTypes/Status_affiliatedwith'
+                            }
+                        ]
+                    }
+                ]
+            }
+        },
+        profile: {
+            entity: {
+                uri: 'entities/1E4APrQW',
+                attributes: {}
+            },
+            history: {},
+            mode
+        },
+        tenant: {
+            id: tenant
+        },
+        ui: {
+            paths: {
+                apiPath: 'https://tst-01.reltio.com/reltio'
+            }
+        },
+        search: {
+            searchOptions: {
+                searchByOv: true,
+                ovOnly: true
+            },
+            globalFilter: {
+                query: null
+            }
+        }
+    };
+};
+
+const defaultConfig = {
+    attributeUri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested',
+    max: 15
+} as TableAttributeViewConfig;
+
+const setUp = (config = defaultConfig, className = '') => {
+    return mount(<ProfileTableAttributeView config={config} className={className} />);
+};
+
+const dispatch = jest.fn();
+
+const mockStore = (store = createStore()) => {
+    jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(store));
+    jest.spyOn(reactRedux, 'useDispatch').mockImplementation(() => dispatch);
+    return store;
+};
+
+describe('ProfileTableAttributeView tests', () => {
+    beforeAll(() => {
+        (TableAttributeView as unknown as jest.Mock).mockImplementation(EmptyStub);
+        (TableAttributeContext.Provider as unknown as jest.Mock).mockImplementation(({children}) => (
+            <div id="tableAttributeContextMock">{children}</div>
+        ));
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('render tests', () => {
+        it('should render TableAttributeContext.Provider correctly', () => {
+            mockStore();
+            const component = setUp();
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toBeDefined();
+            expect(component.find(TableAttributeContext.Provider).prop('value').allColumnsData).toEqual([
+                {
+                    id: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+                    label: 'FirstLevelNestedSub1_HCP',
+                    dataTypeDefinition: {
+                        type: 'DependentLookup',
+                        uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+                        dependentLookupCode: 'LANG_CD',
+                        name: 'FirstLevelNestedSub1'
+                    }
+                },
+                {
+                    id: 'attributes.FirstLevelNested.Date1',
+                    label: 'Date1_HCP',
+                    dataTypeDefinition: {
+                        type: 'Date',
+                        uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/Date1',
+                        name: 'Date1'
+                    }
+                }
+            ]);
+        });
+
+        it('should provide correct allColumnsData for reference attribute type', () => {
+            mockStore();
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/attributes/affiliatedwith'
+            });
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toBeDefined();
+            expect(component.find(TableAttributeContext.Provider).prop('value').allColumnsData).toEqual([
+                {
+                    dataTypeDefinition: {
+                        type: 'String',
+                        uri: 'configuration/entityTypes/Organization/attributes/Nick',
+                        name: 'Nick'
+                    },
+                    id: 'attributes.affiliatedwith.Nick',
+                    label: 'Nickname'
+                },
+                {
+                    dataTypeDefinition: {
+                        type: 'String',
+                        uri: 'configuration/entityTypes/Organization/attributes/Name',
+                        name: 'Name'
+                    },
+                    id: 'attributes.affiliatedwith.Name',
+                    label: 'Name'
+                },
+                {
+                    dataTypeDefinition: {
+                        type: 'String',
+                        uri: 'configuration/relationTypes/affiliatedwith/attributes/Title',
+                        name: 'Title'
+                    },
+                    id: 'attributes.affiliatedwith.Title',
+                    label: 'Title'
+                },
+                {
+                    dataTypeDefinition: {
+                        lookupCode: 'rdm/lookupTypes/Status_affiliatedwith',
+                        type: 'Lookup',
+                        uri: 'configuration/relationTypes/affiliatedwith/attributes/Status',
+                        name: 'Status'
+                    },
+                    id: 'attributes.affiliatedwith.Status',
+                    label: 'Status'
+                }
+            ]);
+        });
+
+        it('should render TableAttributeView correctly', () => {
+            mockStore();
+            const className = 'TesClassName';
+            const component = setUp(defaultConfig, className);
+            expect(component.find(TableAttributeView).prop('config')).toEqual(defaultConfig);
+        });
+    });
+
+    describe('useSingleAttributeLoader tests', () => {
+        it('should not call getPagedEntity if attributeUri is incorrect', async () => {
+            mockStore();
+
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'incorrectUri'
+            });
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                values: [],
+                totalVisibleValues: 0
+            });
+
+            expect(getPagedEntity).not.toHaveBeenCalled();
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+
+        it('should not call getPagedEntity if attributeType is hidden', async () => {
+            mockStore();
+
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/attributes/Commenters'
+            });
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                values: [],
+                totalVisibleValues: 0
+            });
+
+            expect(getPagedEntity).not.toHaveBeenCalled();
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+        it('should call getPagedEntity with correctly params and correctly update state if entity is not DTSS', async () => {
+            const store = mockStore();
+            const values = [{uri: '1', value: '1'}];
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    FirstLevelNested: values,
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/FirstLevelNested': {
+                            totalValues: 1
+                        }
+                    }
+                }
+            });
+
+            const component = setUp();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                values: []
+            });
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                searchQuery: '',
+                globalFilter: ''
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 1,
+                values
+            });
+            expect(dispatch).toHaveBeenCalledWith(
+                profile.actions.processNextPageOfAttributeValues({
+                    parentUri: store.profile.entity.uri,
+                    attributeTypeUri: defaultConfig.attributeUri,
+                    attributeTypeName: 'FirstLevelNested',
+                    values
+                })
+            );
+        });
+
+        it('should call getPagedEntity with correctly params and correctly update state if entity is not DTSS for analytics attributes', async () => {
+            const store = mockStore();
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                analyticsAttributes: {
+                    DQ: ['VALUE 1'],
+                    paging: {
+                        'configuration/entityTypes/HCP/analyticsAttributes/DQ': {
+                            totalOvValues: 1
+                        }
+                    }
+                }
+            });
+
+            const config = {
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/analyticsAttributes/DQ'
+            };
+
+            const component = setUp(config);
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                values: []
+            });
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: config.attributeUri,
+                offset: 0,
+                searchQuery: '',
+                globalFilter: ''
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 1,
+                values: ['VALUE 1'],
+                showTable: true
+            });
+        });
+
+        it('should not call getPagedEntity if attributeUri is is not first level attribute', async () => {
+            mockStore();
+
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/Date1'
+            });
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                values: [],
+                totalVisibleValues: 0
+            });
+
+            expect(getPagedEntity).not.toHaveBeenCalled();
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            expect(getPagedEntity).not.toHaveBeenCalled();
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+
+        it('toggleFilter should work correctly', () => {
+            const store = mockStore();
+            const component = setUp();
+            expect(component.find(TableAttributeContext.Provider).prop('value').filters).toBeNull();
+            const onToggleFilters = component.find(TableAttributeContext.Provider).prop('value').onToggleFilters;
+
+            act(() => {
+                onToggleFilters();
+            });
+
+            component.update();
+            expect(component.find(TableAttributeContext.Provider).prop('value').filters).toEqual({});
+
+            act(() => {
+                onToggleFilters();
+            });
+
+            component.update();
+            expect(component.find(TableAttributeContext.Provider).prop('value').filters).toBeNull();
+
+            expect(getPagedEntity).toHaveBeenCalledTimes(1);
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                searchQuery: '',
+                globalFilter: ''
+            });
+        });
+
+        it('setPage should work correctly', () => {
+            const store = mockStore();
+            const component = setUp();
+            expect(component.find(TableAttributeContext.Provider).prop('value').page).toBe(0);
+
+            act(() => {
+                component.find(TableAttributeContext.Provider).prop('value').setPage(1);
+            });
+
+            component.update();
+            expect(component.find(TableAttributeContext.Provider).prop('value').page).toBe(1);
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 15,
+                searchQuery: '',
+                globalFilter: ''
+            });
+        });
+
+        it('setSearchQuery and filter and sorting should work correctly', () => {
+            const store = mockStore();
+            const component = setUp();
+            expect(component.find(TableAttributeContext.Provider).prop('value').searchQuery).toBe('');
+            expect(component.find(TableAttributeContext.Provider).prop('value').showTable).toBeFalsy();
+
+            act(() => {
+                component.find(TableAttributeContext.Provider).prop('value').setSearchQuery('query');
+            });
+
+            component.update();
+            expect(component.find(TableAttributeContext.Provider).prop('value').searchQuery).toBe('query');
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                searchQuery: 'query',
+                globalFilter: ''
+            });
+            expect(component.find(TableAttributeContext.Provider).prop('value').filters).toBeNull();
+
+            act(() => {
+                component
+                    .find(TableAttributeContext.Provider)
+                    .prop('value')
+                    .onFilter({
+                        columnId: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+                        filter: {
+                            filter: 'equals',
+                            value: [{lookupCode: 'guj', value: 'Gujarati'}]
+                        }
+                    });
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value').filters).toStrictEqual({
+                ['attributes.FirstLevelNested.FirstLevelNestedSub1']: {
+                    filter: 'equals',
+                    value: [{lookupCode: 'guj', value: 'Gujarati'}]
+                }
+            });
+
+            component.update();
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                searchQuery: 'query',
+                globalFilter: '',
+                filters: [
+                    {
+                        filter: 'equals',
+                        fieldName: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+                        values: [[{lookupCode: 'guj', value: 'Gujarati'}]],
+                        type: 'DependentLookup'
+                    }
+                ]
+            });
+
+            act(() => {
+                component
+                    .find(TableAttributeContext.Provider)
+                    .prop('value')
+                    .onSort('attributes.FirstLevelNested.FirstLevelNestedSub1');
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value').sorting).toStrictEqual({
+                order: 'asc',
+                field: 'attributes.FirstLevelNested.FirstLevelNestedSub1'
+            });
+
+            component.update();
+
+            expect(getPagedEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: store.profile.entity,
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: store.profile.entity.uri,
+                defaultMaxValues: 15,
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                searchQuery: 'query',
+                globalFilter: '',
+                filters: [
+                    {
+                        filter: 'equals',
+                        fieldName: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+                        type: 'DependentLookup',
+                        values: [[{lookupCode: 'guj', value: 'Gujarati'}]]
+                    }
+                ],
+                sorting: {
+                    field: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+                    order: 'asc'
+                }
+            });
+            expect(component.find(TableAttributeContext.Provider).prop('value').showTable).toBeTruthy();
+        });
+
+        it('change visible column should work correctly and change sorting', () => {
+            mockStore();
+            const component = setUp();
+
+            act(() => {
+                component
+                    .find(TableAttributeContext.Provider)
+                    .prop('value')
+                    .onSort('attributes.FirstLevelNested.FirstLevelNestedSub1');
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value').sorting).toStrictEqual({
+                order: 'asc',
+                field: 'attributes.FirstLevelNested.FirstLevelNestedSub1'
+            });
+
+            act(() => {
+                component
+                    .find(TableAttributeContext.Provider)
+                    .prop('value')
+                    .onChangeColumns(['attributes.FirstLevelNested.Date1']);
+            });
+
+            component.update();
+
+            expect(component.find(TableAttributeContext.Provider).prop('value').sorting).toStrictEqual({
+                order: 'asc',
+                field: 'attributes.FirstLevelNested.Date1'
+            });
+            expect(component.find(TableAttributeContext.Provider).prop('value').visibleColumns).toEqual([
+                'attributes.FirstLevelNested.Date1'
+            ]);
+        });
+
+        it('should has visible columns as empty array and attributeType should be defined in case with hidden attributeType', () => {
+            mockStore(createStore(true));
+            const component = setUp();
+            const data = component.find(TableAttributeContext.Provider).prop('value');
+
+            expect(data.attributeType).toBeDefined();
+            expect(data.attributeType.hidden).toBeTruthy();
+            expect(data.values).toEqual([]);
+            expect(data.page).toBe(0);
+            expect(data.isLoading).toBe(false);
+            expect(data.showTable).toBeFalsy();
+        });
+
+        it('should pass showTable as false for empty values and filters TableAttributeContext', () => {
+            mockStore(createStore());
+            const component = setUp();
+            const data = component.find(TableAttributeContext.Provider).prop('value');
+            expect(data.values.length).toBe(0);
+            expect(data.showTable).toBeFalsy();
+            expect(data.searchQuery).toBe('');
+            expect(data.filters).toBe(null);
+        });
+
+        it('should pass showTable as true for editing mode', () => {
+            mockStore(createStore(false, Mode.Editing));
+            const component = setUp();
+            const data = component.find(TableAttributeContext.Provider).prop('value');
+            expect(data.values.length).toBe(0);
+            expect(data.showTable).toBeTruthy();
+            expect(data.searchQuery).toBe('');
+            expect(data.filters).toBe(null);
+            expect(data.attributeType.hidden).toBeFalsy();
+        });
+    });
+});