@reltio/dashboard 1.4.1584 → 1.4.1586-mui5

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

@@ -0,0 +1,437 @@
+import React from 'react';
+import moment from 'moment';
+import {renderHook, act} from '@testing-library/react-hooks';
+import {SearchFilter, isLookupAttrType} from '@reltio/mdm-sdk';
+import {SearchFiltersContext} from '@reltio/components';
+import * as mdmSdkModule from '@reltio/mdm-sdk';
+import * as reactReduxImports from 'react-redux';
+import {useFacetRequest} from '../useFacetRequest';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getFacets: jest.fn(),
+    getTotals: jest.fn(),
+    resolveLookupsList: jest.fn(),
+    getAttrTypeLookupCode: jest.fn(),
+    isLookupAttrType: jest.fn()
+}));
+
+describe('useFacetRequest behavior', () => {
+    const initialStore = {
+        search: {
+            searchOptions: {
+                searchByOv: true,
+                ovOnly: true
+            },
+            activityFilter: 'active',
+            globalFilter: {
+                query: 'globalQuery',
+                savedSearchesUris: [],
+                isMuted: false
+            }
+        },
+        ui: {
+            paths: {
+                workflowPath: 'workflowPath',
+                workflowEnvironmentURL: 'workflowEnvironmentURL'
+            },
+            newConfig: {
+                properties: {
+                    showSearchByOv: true
+                }
+            }
+        },
+        tenant: {
+            id: 'tenant'
+        },
+        metadata: {
+            tenant: {
+                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'
+                            }
+                        ],
+                        analyticsAttributes: [
+                            {
+                                uri: 'configuration/entityTypes/HCP/analyticsAttributes/IQ',
+                                label: 'IQ',
+                                name: 'IQ',
+                                type: 'Nested',
+                                analyticsAttributes: [
+                                    {
+                                        uri: 'configuration/entityTypes/HCP/analyticsAttributes/IQ/analyticsAttributes/score',
+                                        type: 'Int',
+                                        label: 'Reltio Score',
+                                        name: 'score'
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                roles: [
+                    {
+                        label: 'My test role',
+                        uri: 'configuration/roles/MyRole'
+                    }
+                ]
+            }
+        }
+    };
+
+    let resolveFacets;
+    let rejectFacets;
+    const getFacetsSpy = jest.spyOn(mdmSdkModule, 'getFacets');
+    const getTotalsSpy = jest.spyOn(mdmSdkModule, 'getTotals');
+
+    let resolveLookups;
+    const resolveLookupsListSpy = jest.spyOn(mdmSdkModule, 'resolveLookupsList');
+
+    beforeEach(() => {
+        getFacetsSpy.mockReturnValue(
+            new Promise((resolve, reject) => {
+                resolveFacets = resolve;
+                rejectFacets = reject;
+            })
+        );
+        getTotalsSpy.mockResolvedValue({total: 10});
+        resolveLookupsListSpy.mockReturnValue(
+            new Promise((resolve) => {
+                resolveLookups = resolve;
+            })
+        );
+        jest.spyOn(reactReduxImports, 'useSelector').mockImplementation((selector) => selector(initialStore));
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    const facetResponse = {'attributes.CountryCode': {US: 300000, BQ: 11, BM: 1, DZ: 1}};
+    const facetsQuery =
+        "filter=(equals(type,'configuration/entityTypes/HCP'))" +
+        ' and (globalQuery)&options=searchByOv&activeness=active';
+    const attributeUri = 'configuration/entityTypes/HCP/attributes/CountryCode';
+    const defaultRequest = {
+        body: [
+            {
+                fieldName: 'attributes.CountryCode',
+                orderType: 'reversedCount',
+                pageNo: 1,
+                pageSize: 8
+            }
+        ],
+        query: facetsQuery
+    };
+    const initialProps = {filters: [], attributeUri, pageSize: 8};
+
+    it('should send request and be in the loading state, and be in loaded state once data is loaded', async () => {
+        const {result} = renderHook(useFacetRequest, {initialProps});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith(defaultRequest);
+        await act(async () => {
+            resolveFacets(facetResponse);
+        });
+
+        expect(result.current.state).toBe('loaded');
+        expect(result.current.data).toEqual([
+            {
+                label: 'US',
+                group: 'US',
+                value: 300000,
+                localizedValue: '300,000'
+            },
+            {label: 'BQ', group: 'BQ', value: 11, localizedValue: '11'},
+            {label: 'BM', group: 'BM', value: 1, localizedValue: '1'},
+            {label: 'DZ', group: 'DZ', value: 1, localizedValue: '1'}
+        ]);
+    });
+
+    it('should send request without options=searchByOv if showSearchByOv is false', async () => {
+        jest.spyOn(reactReduxImports, 'useSelector').mockImplementation((selector) =>
+            selector({
+                ...initialStore,
+                ui: {
+                    ...initialStore.ui,
+                    newConfig: {
+                        properties: {
+                            showSearchByOv: false
+                        }
+                    }
+                }
+            })
+        );
+        const {result} = renderHook(useFacetRequest, {initialProps});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({
+            ...defaultRequest,
+            query: "filter=(equals(type,'configuration/entityTypes/HCP')) and (globalQuery)&activeness=active"
+        });
+        await act(async () => {
+            resolveFacets(facetResponse);
+        });
+
+        expect(result.current.state).toBe('loaded');
+    });
+
+    it('should return error state if loading is failed', async () => {
+        const {result} = renderHook(useFacetRequest, {initialProps});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith(defaultRequest);
+        await act(async () => {
+            rejectFacets();
+        });
+
+        expect(result.current.state).toBe('error');
+    });
+
+    it('should not localize values when attributeUri in ui.attributePresentations', async () => {
+        jest.spyOn(reactReduxImports, 'useSelector').mockImplementation((selector) =>
+            selector({
+                ...initialStore,
+                ui: {
+                    ...initialStore.ui,
+                    attributePresentations: {
+                        [attributeUri]: {thousandSeparator: ''}
+                    }
+                }
+            })
+        );
+        const {result} = renderHook(useFacetRequest, {initialProps});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith(defaultRequest);
+        await act(async () => {
+            resolveFacets(facetResponse);
+        });
+
+        expect(result.current.state).toBe('loaded');
+        expect(result.current.data).toEqual([
+            {label: 'US', group: 'US', value: 300000},
+            {label: 'BQ', group: 'BQ', value: 11},
+            {label: 'BM', group: 'BM', value: 1},
+            {label: 'DZ', group: 'DZ', value: 1}
+        ]);
+    });
+
+    it('should load special attributes', async () => {
+        const props = {...initialProps, attributeUri: 'tags'};
+        const {result} = renderHook(useFacetRequest, {initialProps: props});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({
+            body: [
+                {
+                    fieldName: 'tags',
+                    orderType: 'reversedCount',
+                    pageNo: 1,
+                    pageSize: 8
+                }
+            ],
+            query: 'filter=globalQuery&options=searchByOv&activeness=active'
+        });
+        await act(async () => {
+            resolveFacets({tags: {tag1: 1, tag2: 2, tag3: 3, tag4: 1}});
+        });
+
+        expect(result.current.state).toBe('loaded');
+        const labels = result.current.data.map(({label}) => label);
+        expect(labels).toEqual(['tag3', 'tag2', 'tag1', 'tag4']);
+    });
+
+    it('should load roles correctly', async () => {
+        const props = {...initialProps, attributeUri: 'roles'};
+        const {result} = renderHook(useFacetRequest, {initialProps: props});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({
+            body: [
+                {
+                    fieldName: 'roles',
+                    orderType: 'reversedCount',
+                    pageNo: 1,
+                    pageSize: 8
+                }
+            ],
+            query: 'filter=globalQuery&options=searchByOv&activeness=active'
+        });
+        await act(async () => {
+            resolveFacets({roles: {MyRole: 1}});
+        });
+
+        expect(result.current.state).toBe('loaded');
+        const labels = result.current.data.map(({label}) => label);
+        expect(labels).toEqual(['My test role']);
+    });
+
+    it('should load date attributes correctly', async () => {
+        const props = {...initialProps, attributeUri: 'configuration/entityTypes/HCP/attributes/Date'};
+        const {result} = renderHook(useFacetRequest, {initialProps: props});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({
+            body: [
+                {
+                    fieldName: 'attributes.Date',
+                    orderType: 'reversedCount',
+                    pageNo: 1,
+                    pageSize: 8
+                }
+            ],
+            query: facetsQuery
+        });
+        await act(async () => {
+            resolveFacets({
+                'attributes.Date': {
+                    '1620432000000': 19
+                }
+            });
+        });
+
+        expect(result.current.state).toBe('loaded');
+        const labels = result.current.data.map(({label}) => label);
+        expect(labels).toEqual([moment(1620432000000).format('L')]);
+    });
+
+    it('should load analytics attributes correctly', async () => {
+        const props = {
+            ...initialProps,
+            attributeUri: 'configuration/entityTypes/HCP/analyticsAttributes/IQ/analyticsAttributes/score'
+        };
+        const {result} = renderHook(useFacetRequest, {initialProps: props});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({
+            body: [
+                {
+                    fieldName: 'analyticsAttributes.IQ.score',
+                    orderType: 'reversedCount',
+                    pageNo: 1,
+                    pageSize: 8
+                }
+            ],
+            query: facetsQuery
+        });
+        await act(async () => {
+            resolveFacets({'analyticsAttributes.IQ.score': {11: 2}});
+        });
+
+        expect(result.current.state).toBe('loaded');
+        expect(result.current.data).toEqual([{value: 2, label: '11', group: '11', localizedValue: '2'}]);
+    });
+
+    it('should send an additional request for other values if option is passed', async () => {
+        const filters = [{fieldName: 'attributes.Int', filter: 'range', values: ['1', '2']}];
+        const facetsQueryWithOptions =
+            "filter=(equals(type,'configuration/entityTypes/HCP')" +
+            ' and range(attributes.Int,1,2))' +
+            ' and (globalQuery)&options=searchByOv&activeness=active';
+        const props = {...initialProps, filters, options: {showOthers: true}};
+        const {result} = renderHook(useFacetRequest, {initialProps: props});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({...defaultRequest, query: facetsQueryWithOptions});
+        await act(async () => {
+            resolveFacets(facetResponse);
+        });
+
+        const getTotalFiltersValues = getTotalsSpy.mock.calls[0][0]?.map(({values}) => values[0]);
+        const getTotalOptions = getTotalsSpy.mock.calls[0][1];
+        expect(getTotalFiltersValues).toEqual(['configuration/entityTypes/HCP', ['1', '2'], 'US', 'BQ', 'BM', 'DZ']);
+        expect(getTotalOptions).toEqual({
+            activityFilter: 'active',
+            globalFilter: 'globalQuery',
+            searchOptions: 'searchByOv'
+        });
+
+        expect(result.current.state).toBe('loaded');
+        const data = result.current.data;
+        const groups = data.map(({group}) => group);
+        const othersCount = data.find(({group}) => group === 'Other')?.value;
+        expect(groups).toEqual(['US', 'BQ', 'BM', 'DZ', 'Other']);
+        expect(othersCount).toBe(10);
+    });
+
+    it('should resend request when invoke reload', async () => {
+        const {result} = renderHook(useFacetRequest, {initialProps});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith(defaultRequest);
+        await act(async () => {
+            resolveFacets(facetResponse);
+        });
+
+        expect(result.current.state).toBe('loaded');
+        await act(async () => {
+            result.current.reload();
+        });
+        expect(getFacetsSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should resolve lookups for data with lookups', async () => {
+        const lookupCode = 'COUNTRY_CD';
+        (isLookupAttrType as jest.Mock).mockReturnValue(true);
+        jest.spyOn(mdmSdkModule, 'getAttrTypeLookupCode').mockReturnValue(lookupCode);
+        const {result} = renderHook(useFacetRequest, {initialProps});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith(defaultRequest);
+        await act(async () => {
+            resolveFacets(facetResponse);
+        });
+
+        expect(resolveLookupsListSpy).toBeCalledWith(
+            ['US', 'BQ', 'BM', 'DZ'].map((codeValue) => ({codeValue, type: lookupCode}))
+        );
+        await act(async () => {
+            resolveLookups([
+                {COUNTRY_CD: {US: {displayName: 'USA'}}},
+                {COUNTRY_CD: {BQ: {displayName: 'Bonaire, Sint Eustatius and Saba'}}},
+                {COUNTRY_CD: {BM: {displayName: 'Bermuda'}}},
+                {COUNTRY_CD: {DZ: {displayName: 'Algeria'}}}
+            ]);
+        });
+
+        expect(result.current.state).toBe('loaded');
+        const labels = result.current.data.map(({label}) => label);
+        expect(labels).toEqual(['USA', 'Bonaire, Sint Eustatius and Saba', 'Bermuda', 'Algeria']);
+    });
+
+    it('should go to error state if attribute uri is undefined', () => {
+        const props = {...initialProps, attributeUri: undefined as unknown as string};
+        const {result} = renderHook(useFacetRequest, {initialProps: props});
+
+        expect(result.current.state).toBe('error');
+    });
+
+    it('should take into account special filters', async () => {
+        const facetQueryWithSpecialFilters =
+            "filter=(equals(type,'configuration/entityTypes/HCP')" +
+            " and equals(attributes.Test,'123'))" +
+            ' and (globalQuery)&options=searchByOv&activeness=active';
+        const filterValue: SearchFilter[] = [{fieldName: 'attributes.Test', filter: 'equals', values: ['123']}];
+        const Wrapper = ({children}: {children?: React.ReactNode}) => (
+            <SearchFiltersContext.Provider value={filterValue}>{children}</SearchFiltersContext.Provider>
+        );
+        const {result} = renderHook(useFacetRequest, {initialProps, wrapper: Wrapper});
+
+        expect(result.current.state).toBe('loading');
+        expect(getFacetsSpy).toBeCalledWith({...defaultRequest, query: facetQueryWithSpecialFilters});
+    });
+});

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

@@ -0,0 +1,103 @@
+import * as mdmSdkModule from '@reltio/mdm-sdk';
+import React from 'react';
+import {act} from 'react-dom/test-utils';
+import {asyncCheck} from '../../../../../__mocks__/test-utils';
+import {mount} from 'enzyme';
+import {useFilteredEntitiesRequest} from '../useFilteredEntitiesRequest';
+import {SearchFilter} from '@reltio/mdm-sdk';
+import {SearchFiltersContext} from '@reltio/components';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getFilteredEntities: jest.fn(),
+    getTotals: jest.fn()
+}));
+
+const payload = {
+    max: 10,
+    offset: 0,
+    filters: [
+        {
+            filter: 'equals',
+            fieldName: 'attributes.Phone.ValidationStatus',
+            values: ['VALID']
+        }
+    ]
+};
+
+describe('useFilteredEntitiesRequest behavior', () => {
+    const TestComponent = () => {
+        const {data, state, reload, total} = useFilteredEntitiesRequest(payload);
+        return state ? <div className={'test'} data-test={{state, data, reload, total}} /> : null;
+    };
+    const tableData = [{label: 'Crazy-mini'}, {label: 'crazySS'}];
+    const hookResponse = [{label: 'Crazy-mini'}, {label: 'crazySS'}];
+
+    const totalResponse = {total: 10};
+    const getHooksValues = (component) => component.find('TestComponent').childAt(0).prop('data-test');
+    it('should send request and be in the loading state, and be in loaded state once data is loaded', (done) => {
+        jest.spyOn(mdmSdkModule, 'getFilteredEntities').mockImplementation(() => {
+            return Promise.resolve(hookResponse);
+        });
+        jest.spyOn(mdmSdkModule, 'getTotals').mockImplementation(() => {
+            return Promise.resolve(totalResponse);
+        });
+        let component;
+        act(() => {
+            component = mount(<TestComponent />);
+        });
+        act(() => {
+            component.update();
+            const {state} = getHooksValues(component);
+            expect(state).toBe('loading');
+        });
+
+        asyncCheck(() => {
+            act(() => {
+                component.update();
+            });
+            const {state, data, total} = getHooksValues(component);
+            expect(state).toBe('loaded');
+            expect(data).toStrictEqual(tableData);
+            expect(total).toEqual(totalResponse.total);
+        }, done);
+    });
+
+    it('should add special filters to the request', (done) => {
+        jest.spyOn(mdmSdkModule, 'getFilteredEntities').mockImplementation((filters) => {
+            if (filters[0].fieldName === 'attributes.Test') {
+                return Promise.resolve(hookResponse);
+            }
+        });
+        jest.spyOn(mdmSdkModule, 'getTotals').mockImplementation((filters) => {
+            if (filters[0].fieldName === 'attributes.Test') {
+                return Promise.resolve(totalResponse);
+            }
+        });
+        let component;
+        const filterValue: SearchFilter[] = [
+            {
+                fieldName: 'attributes.Test',
+                filter: 'equals',
+                values: ['123']
+            }
+        ];
+        act(() => {
+            component = mount(
+                <SearchFiltersContext.Provider value={filterValue}>
+                    <TestComponent />
+                </SearchFiltersContext.Provider>
+            );
+        });
+
+        asyncCheck(() => {
+            act(() => {
+                component.update();
+            });
+            const {state, data, total} = getHooksValues(component);
+            expect(state).toBe('loaded');
+            expect(data).toStrictEqual(tableData);
+            expect(total).toEqual(totalResponse.total);
+        }, done);
+    });
+});