@reltio/dashboard 1.4.1584 → 1.4.1586-mui5

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

@@ -0,0 +1,201 @@
+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 {useSavedSearchesRequest} from '../useSavedSearchesRequest';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getSavedSearches: jest.fn(),
+    getTotalsForQuery: jest.fn<Promise<any>, [string]>()
+}));
+
+describe('useSavedSearchesRequest behavior', () => {
+    const TestComponent = ({payload}) => {
+        const {data, state, reload, total} = useSavedSearchesRequest(payload);
+        return state ? <div data-test={{state, data, reload, total}} /> : null;
+    };
+    const savedSearchResponseCommonPart = {
+        favoriteOnly: true,
+        max: 10,
+        offset: 0,
+        sortBy: 'NAME',
+        sortOrder: 'ASC',
+        total: 10
+    };
+
+    const getHooksValues = (component) => component.find('TestComponent').childAt(0).prop('data-test');
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should send request and be in the loading state, and be in loaded state once data is loaded', (done) => {
+        const payload = {
+            max: 10,
+            options: {
+                favoriteOnly: true,
+                countResults: false
+            },
+            offset: 0
+        };
+
+        const hookResponse = {
+            ...savedSearchResponseCommonPart,
+            result: [
+                {name: 'Crazy-mini', uri: 'savedSavedSearch/1'},
+                {name: 'crazySS', count: 18900000, uri: 'savedSearch/2'}
+            ]
+        };
+        jest.spyOn(mdmSdkModule, 'getSavedSearches').mockImplementation(() => {
+            return Promise.resolve(hookResponse);
+        });
+        let component;
+        act(() => {
+            component = mount(<TestComponent payload={payload} />);
+        });
+        act(() => {
+            component.update();
+            const {state} = getHooksValues(component);
+            expect(state).toBe('loading');
+        });
+
+        asyncCheck(() => {
+            act(() => {
+                component.update();
+            });
+            const {state, data} = getHooksValues(component);
+            expect(state).toBe('loaded');
+            expect(data).toStrictEqual(hookResponse.result);
+        }, done);
+    });
+
+    it('should send total requests if option countResults is true', (done) => {
+        const payload = {
+            max: 10,
+            options: {
+                favoriteOnly: true,
+                countResults: true
+            },
+            offset: 0
+        };
+
+        const hookResponse = {
+            ...savedSearchResponseCommonPart,
+            result: [
+                {
+                    name: 'Crazy-mini',
+                    uri: 'savedSavedSearch/1',
+                    query: encodeURIComponent("savedSearch1 range(activeness.startDate,'${lastDay}','${now}')")
+                },
+                {
+                    name: 'crazySS',
+                    uri: 'savedSearch/2',
+                    query: encodeURIComponent("savedSearch2 equals(type,'configuration/entityTypes/People')")
+                },
+                {name: 'wrong', uri: 'savedSearch/2', query: encodeURIComponent('wrong query')}
+            ]
+        };
+        jest.spyOn(mdmSdkModule, 'getSavedSearches').mockImplementation(() => {
+            return Promise.resolve(hookResponse);
+        });
+
+        const getTotalsForQuerySpy = jest
+            .spyOn(mdmSdkModule, 'getTotalsForQuery')
+            .mockImplementation((query: string) => {
+                if (query.includes('savedSearch1')) {
+                    return Promise.resolve({total: 1});
+                }
+                if (query.includes('savedSearch2')) {
+                    return Promise.resolve({total: 2});
+                }
+                return Promise.reject('Error from total');
+            });
+
+        let component;
+        act(() => {
+            component = mount(<TestComponent payload={payload} />);
+        });
+        act(() => {
+            component.update();
+            const {state} = getHooksValues(component);
+            expect(state).toBe('loading');
+        });
+
+        asyncCheck(() => {
+            act(() => {
+                component.update();
+            });
+            const {state, data} = getHooksValues(component);
+            expect(state).toBe('loaded');
+            expect(data).toStrictEqual([
+                {...hookResponse.result[0], count: 1},
+                {...hookResponse.result[1], count: 2},
+                hookResponse.result[2]
+            ]);
+            expect(getTotalsForQuerySpy.mock.calls.length).toBe(3);
+            expect(getTotalsForQuerySpy.mock.calls[0][0]).not.toContain('lastDay');
+            expect(getTotalsForQuerySpy.mock.calls[0][0]).not.toContain('now');
+        }, done);
+    });
+
+    it('should not fail with nil options', async () => {
+        const payload = {
+            max: 10,
+            offset: 0
+        };
+
+        const hookResponse = {
+            ...savedSearchResponseCommonPart,
+            result: [
+                {
+                    name: 'Crazy-mini',
+                    uri: 'savedSavedSearch/1',
+                    query: encodeURIComponent("savedSearch1 range(activeness.startDate,'${lastDay}','${now}')")
+                },
+                {
+                    name: 'crazySS',
+                    uri: 'savedSearch/2',
+                    query: encodeURIComponent("savedSearch2 equals(type,'configuration/entityTypes/People')")
+                },
+                {name: 'wrong', uri: 'savedSearch/2', query: encodeURIComponent('wrong query')}
+            ]
+        };
+        jest.spyOn(mdmSdkModule, 'getSavedSearches').mockImplementation(() => {
+            return Promise.resolve(hookResponse);
+        });
+
+        let component;
+        await act(async () => {
+            component = mount(<TestComponent payload={payload} />);
+        });
+        component.update();
+
+        const {state, data} = getHooksValues(component);
+        expect(state).toBe('loaded');
+        expect(data).toStrictEqual(hookResponse.result);
+    });
+
+    it('should not fail when response.result is undefined', async () => {
+        const payload = {
+            max: 10,
+            options: {
+                favoriteOnly: true,
+                countResults: true
+            },
+            offset: 0
+        };
+        jest.spyOn(mdmSdkModule, 'getSavedSearches').mockImplementation(() => {
+            return Promise.resolve(savedSearchResponseCommonPart);
+        });
+
+        let component;
+        await act(async () => {
+            component = mount(<TestComponent payload={payload} />);
+        });
+        component.update();
+
+        const {state, data} = getHooksValues(component);
+        expect(state).toBe('loaded');
+        expect(data).toStrictEqual([]);
+    });
+});

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

@@ -0,0 +1,212 @@
+import {renderHook, act} from '@testing-library/react-hooks';
+import * as mdmSdkModule from '@reltio/mdm-sdk';
+import {DateRangeValue} from '@reltio/mdm-sdk';
+import {RequestStates} from '@reltio/components';
+import {PeriodStep} from '../../types/PeriodStep';
+import {useStatsRequest} from '../useStatsRequest';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getEntitiesStats: jest.fn(),
+    getDateRangeByDatePeriod: jest.fn()
+}));
+
+const START_TIME = 123;
+const END_TIME = 456;
+
+describe('useStatsRequest behavior', () => {
+    const getEntitiesStats = jest.spyOn(mdmSdkModule, 'getEntitiesStats');
+    const getDateRangeByDatePeriod = jest.spyOn(mdmSdkModule, 'getDateRangeByDatePeriod');
+
+    const getEmptyEventData = (event: string) => ({
+        event,
+        total: 0,
+        data: [
+            {term: START_TIME, count: 0},
+            {term: END_TIME, count: 0}
+        ]
+    });
+    const fullStatsRequest = {
+        facet: 'type',
+        types: [
+            'CREATED',
+            'UPDATED',
+            'DELETED',
+            'POTENTIAL_MATCHES_FOUND',
+            'MERGED',
+            'MERGED_ON_THE_FLY',
+            'MERGED_MANUALLY',
+            'SPLITTED',
+            'NOT_MATCHES_SET'
+        ],
+        startTime: START_TIME,
+        endTime: END_TIME
+    };
+
+    let resolveRequest;
+    let rejectRequest;
+    beforeAll(() => {
+        getEntitiesStats.mockImplementation(({facet, types}) => {
+            switch (facet) {
+                case 'type': {
+                    return new Promise((resolve, reject) => {
+                        resolveRequest = resolve;
+                        rejectRequest = reject;
+                    });
+                }
+                case PeriodStep.HOUR: {
+                    if (types.includes('CREATED')) {
+                        return Promise.resolve({
+                            total: 150,
+                            facets: {
+                                hour: [{term: '2021-04-05T04', count: 150}]
+                            }
+                        });
+                    }
+                    if (types.includes('DELETED')) {
+                        return Promise.resolve({
+                            total: 50,
+                            facets: {
+                                hour: [{term: '2021-04-05T09', count: 50}]
+                            }
+                        });
+                    }
+                    return Promise.reject();
+                }
+                default: {
+                    return Promise.reject();
+                }
+            }
+        });
+        getDateRangeByDatePeriod.mockImplementation(() => [START_TIME, END_TIME]);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should send request and be in the loading state, and be in loaded state once data is loaded', async () => {
+        const {result} = renderHook(useStatsRequest, {initialProps: DateRangeValue.LAST_DAY});
+        expect(result.current).toMatchObject({
+            state: RequestStates.LOADING,
+            step: PeriodStep.HOUR,
+            data: []
+        });
+
+        await act(async () => {
+            resolveRequest({
+                total: 200,
+                facets: {
+                    type: [
+                        {term: 'CREATED', count: 150},
+                        {term: 'DELETED', count: 50}
+                    ]
+                }
+            });
+        });
+
+        expect(mdmSdkModule.getDateRangeByDatePeriod).toBeCalledWith(DateRangeValue.LAST_DAY, expect.anything());
+        expect(getEntitiesStats).toBeCalledWith(fullStatsRequest);
+        expect(getEntitiesStats).toBeCalledWith({
+            facet: PeriodStep.HOUR,
+            types: ['CREATED'],
+            startTime: START_TIME,
+            endTime: END_TIME
+        });
+        expect(getEntitiesStats).toBeCalledWith({
+            facet: PeriodStep.HOUR,
+            types: ['DELETED'],
+            startTime: START_TIME,
+            endTime: END_TIME
+        });
+
+        expect(result.current).toMatchObject({
+            state: RequestStates.LOADED,
+            step: PeriodStep.HOUR,
+            data: [
+                {
+                    event: 'created',
+                    total: 150,
+                    data: [
+                        {term: START_TIME, count: 0},
+                        {term: 1617595200000, count: 150},
+                        {term: END_TIME, count: 0}
+                    ]
+                },
+                getEmptyEventData('updated'),
+                {
+                    event: 'deleted',
+                    total: 50,
+                    data: [
+                        {term: START_TIME, count: 0},
+                        {term: 1617613200000, count: 50},
+                        {term: END_TIME, count: 0}
+                    ]
+                },
+                getEmptyEventData('matched'),
+                getEmptyEventData('autoMerged'),
+                getEmptyEventData('mergedManually'),
+                getEmptyEventData('unmerged'),
+                getEmptyEventData('notMatch')
+            ]
+        });
+    });
+
+    it('should resend request when invoke reload', () => {
+        const {result} = renderHook(useStatsRequest, {initialProps: DateRangeValue.LAST_DAY});
+        expect(getEntitiesStats).toBeCalledWith(fullStatsRequest);
+
+        getEntitiesStats.mockClear();
+        act(() => {
+            result.current.reload();
+        });
+        expect(getEntitiesStats).toBeCalledWith(fullStatsRequest);
+    });
+
+    it('should clear data before load new and return ERROR state if request rejected', async () => {
+        const {result} = renderHook(useStatsRequest, {initialProps: DateRangeValue.LAST_DAY});
+        expect(result.current).toMatchObject({
+            state: RequestStates.LOADING,
+            step: PeriodStep.HOUR,
+            data: []
+        });
+
+        await act(async () => {
+            resolveRequest({
+                total: 200,
+                facets: {
+                    type: [
+                        {term: 'CREATED', count: 150},
+                        {term: 'DELETED', count: 50}
+                    ]
+                }
+            });
+        });
+
+        expect(result.current).toMatchObject({
+            state: RequestStates.LOADED,
+            step: PeriodStep.HOUR,
+            data: expect.arrayContaining([getEmptyEventData('matched')])
+        });
+
+        act(() => {
+            result.current.reload();
+        });
+
+        expect(result.current).toMatchObject({
+            state: RequestStates.LOADING,
+            step: PeriodStep.HOUR,
+            data: []
+        });
+
+        await act(async () => {
+            rejectRequest('Error');
+        });
+
+        expect(result.current).toMatchObject({
+            state: RequestStates.ERROR,
+            step: PeriodStep.HOUR,
+            data: []
+        });
+    });
+});