@reltio/profile 1.4.1585 → 1.4.1586-mui5

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

@@ -0,0 +1,933 @@
+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, SingleAttributeViewConfig} from '@reltio/mdm-sdk';
+import {profile, ui} from '@reltio/mdm-module';
+import {ProfileSingleAttributeView} from '../ProfileSingleAttributeView';
+import {SingleAttributeView} from '../components/SingleAttributeView/SingleAttributeView';
+import {SingleAttributeContext} from '../contexts/SingleAttributeContext';
+import {getPagedLocalEntity} from '../../hooks/helpers';
+import {delayPromise} from '../../../../../../__mocks__/test-utils';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...(jest.requireActual('@reltio/mdm-sdk') as Record<string, unknown>),
+    getPagedEntity: jest.fn().mockResolvedValue({})
+}));
+
+jest.mock('../../hooks/helpers', () => ({
+    ...(jest.requireActual('../../hooks/helpers') as Record<string, unknown>),
+    getPagedLocalEntity: jest.fn().mockResolvedValue({})
+}));
+
+jest.mock('../components/SingleAttributeView/SingleAttributeView', () => ({
+    SingleAttributeView: jest.fn()
+}));
+
+jest.mock('../contexts/SingleAttributeContext', () => ({
+    SingleAttributeContext: {
+        Provider: jest.fn()
+    }
+}));
+
+const createStore = (isDataTenantEntity = false, isTempEnity = false, history = {}) => {
+    const tenant = 'knest';
+
+    return {
+        metadata: {
+            [tenant]: {
+                uri: 'configuration',
+                entityTypes: [
+                    {
+                        uri: 'configuration/entityTypes/HCP',
+                        attributes: [
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/Address'
+                            },
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/TestAttribute'
+                            },
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/TestAttribute/attributes/SecondLevelNested'
+                            },
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/Commenters',
+                                hidden: true
+                            }
+                        ],
+                        analyticsAttributes: [
+                            {
+                                uri: 'configuration/entityTypes/HCP/analyticsAttributes/DQ'
+                            }
+                        ]
+                    }
+                ]
+            }
+        },
+        profile: {
+            entity: {
+                uri: isTempEnity ? 'entities/uri$$tempo' : 'entities/1E4APrQW',
+                dataTenant: isDataTenantEntity ? 'uitest3' : undefined,
+                attributes: {
+                    TestAttribute: [
+                        {uri: '2', value: 'testValue'},
+                        {uri: '3', value: 'testOvFalseValue', ov: false}
+                    ]
+                }
+            },
+            mode: 'Viewing',
+            history
+        },
+        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/Address',
+    max: 15
+} as SingleAttributeViewConfig;
+
+const setUp = (config?: SingleAttributeViewConfig, className?: string) => {
+    return mount(<ProfileSingleAttributeView config={config || defaultConfig} 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('ProfileSingleAttributeView tests', () => {
+    beforeAll(() => {
+        (SingleAttributeView as unknown as jest.Mock).mockImplementation(EmptyStub);
+        (SingleAttributeContext.Provider as unknown as jest.Mock).mockImplementation(({children}) => (
+            <div id="singleAttributeContextMock">{children}</div>
+        ));
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('render tests', () => {
+        it('should render SingleAttributeContext.Provider correctly', () => {
+            mockStore();
+            const component = setUp();
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toBeDefined();
+        });
+
+        it('should render SingleAttributeView correctly', () => {
+            mockStore();
+            const component = setUp();
+            expect(component.find(SingleAttributeView).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(SingleAttributeContext.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(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+
+        it('should not call getPagedEntity if attributeUri is is not first level attribute', async () => {
+            mockStore();
+
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/attributes/TestAttribute/attributes/SecondLevelNested'
+            });
+
+            expect(component.find(SingleAttributeContext.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(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+
+        it('should not call getPagedEntity if attributeType is hidden', async () => {
+            mockStore();
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Commenters': {
+                            totalOvValues: 1
+                        }
+                    }
+                }
+            });
+
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/attributes/Commenters'
+            });
+
+            expect(component.find(SingleAttributeContext.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(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+
+        it('should not call getPagedEntity if entity is temporary', async () => {
+            mockStore(createStore(false, true));
+            (getPagedEntity as jest.Mock).mockResolvedValue({});
+
+            const component = setUp();
+
+            expect(component.find(SingleAttributeContext.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(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+        });
+
+        it('should call getPagedEntity with correct params and correct update state if entity is not DTSS', async () => {
+            const store = mockStore();
+            const values = [{uri: '1', value: '1'}];
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: values,
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalValues: 1
+                        }
+                    }
+                }
+            });
+
+            const component = setUp();
+
+            expect(component.find(SingleAttributeContext.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,
+                searchQuery: '',
+                globalFilter: '',
+                offset: 0,
+                options: undefined
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.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: 'Address',
+                    values
+                })
+            );
+        });
+
+        it('should call getPagedEntity with default max param if it is not passed', async () => {
+            const store = mockStore();
+            const values = [{uri: '1', value: '1'}];
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: values,
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalValues: 1
+                        }
+                    }
+                }
+            });
+
+            setUp({
+                attributeUri: 'configuration/entityTypes/HCP/attributes/Address',
+                max: undefined
+            } as SingleAttributeViewConfig);
+
+            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,
+                searchQuery: '',
+                globalFilter: '',
+                offset: 0,
+                options: undefined
+            });
+        });
+
+        it('should show error from getPagedEntity and update state with empty array for values', async () => {
+            const errorMessage = 'test Error message';
+
+            (getPagedEntity as jest.Mock).mockRejectedValue({
+                error: errorMessage
+            });
+
+            const component = setUp();
+
+            await act(async () => {
+                await delayPromise();
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+            expect(dispatch).toHaveBeenCalledWith(ui.actions.errorSet(errorMessage));
+        });
+
+        it('should clear values after switching from real entity to temporary', async () => {
+            const store = mockStore();
+            const values = [{uri: '1', value: '1'}];
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: values,
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalValues: 1
+                        }
+                    }
+                }
+            });
+
+            const component = setUp();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                values: []
+            });
+
+            expect(getPagedEntity).toHaveBeenCalled();
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.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: 'Address',
+                    values
+                })
+            );
+
+            //switch to new temp entity
+            mockStore(createStore(false, true));
+            component.setProps({});
+            await act(async () => {
+                await Promise.resolve();
+            });
+            component.update();
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+            expect(getPagedEntity).toHaveBeenCalledTimes(1);
+            expect(dispatch).toHaveBeenCalledTimes(1);
+        });
+
+        it('should call getPagedEntity with correct params and correct 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': {
+                            totalValues: 1
+                        }
+                    }
+                }
+            });
+
+            const config = {
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/analyticsAttributes/DQ'
+            };
+
+            const component = setUp(config);
+
+            expect(component.find(SingleAttributeContext.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,
+                searchQuery: '',
+                globalFilter: '',
+                offset: 0,
+                options: undefined
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 1,
+                values: ['VALUE 1']
+            });
+        });
+
+        it('should call getPagedLocalEntity with correct params and correct update state if entity is DTSS', async () => {
+            const store = mockStore(createStore(true));
+            (getPagedLocalEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: ['VALUE 1', 'VALUE 2'],
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalOvValues: 2
+                        }
+                    }
+                }
+            });
+
+            const component = setUp();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+
+            expect(getPagedLocalEntity).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,
+                searchQuery: '',
+                globalFilter: '',
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                options: undefined
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 2,
+                values: ['VALUE 1', 'VALUE 2']
+            });
+        });
+
+        it('should call getPagedLocalEntity with correct params and correct update state if entity is DTSS for analytics attributes', async () => {
+            const store = mockStore(createStore(true));
+            (getPagedLocalEntity as jest.Mock).mockResolvedValue({
+                analyticsAttributes: {
+                    DQ: ['VALUE 1', 'VALUE 2'],
+                    paging: {
+                        'configuration/entityTypes/HCP/analyticsAttributes/DQ': {
+                            totalOvValues: 2
+                        }
+                    }
+                }
+            });
+
+            const component = setUp({
+                ...defaultConfig,
+                attributeUri: 'configuration/entityTypes/HCP/analyticsAttributes/DQ'
+            });
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                values: []
+            });
+
+            expect(getPagedLocalEntity).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,
+                searchQuery: '',
+                globalFilter: '',
+                attributeTypeUri: 'configuration/entityTypes/HCP/analyticsAttributes/DQ',
+                offset: 0,
+                options: undefined
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 2,
+                values: ['VALUE 1', 'VALUE 2']
+            });
+        });
+
+        it('should call getPagedLocalEntity with correct params and correct update state if history is active', async () => {
+            const history = {
+                slice: {aEntity: {uri: 'entity/entityUri'}, bEntity: {a: 1}},
+                diff: {
+                    attributes: {
+                        TestAttribute: [{uri: '3', value: 'newValue'}]
+                    },
+                    roles: [],
+                    tags: []
+                }
+            };
+            const store = mockStore(createStore(false, false, history));
+            (getPagedLocalEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: ['VALUE 1', 'VALUE 2'],
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalOvValues: 2,
+                            totalValues: 2
+                        }
+                    }
+                }
+            });
+
+            const component = setUp();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                totalVisibleValues: 0,
+                values: []
+            });
+
+            expect(getPagedLocalEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: {
+                    ...history.slice.aEntity,
+                    ...history.diff
+                },
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: history.slice.aEntity.uri,
+                defaultMaxValues: 15,
+                searchQuery: '',
+                globalFilter: '',
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                options: undefined
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 2,
+                values: ['VALUE 1', 'VALUE 2']
+            });
+
+            expect(dispatch).not.toHaveBeenCalled();
+        });
+
+        it('setPage should work correctly', () => {
+            const store = mockStore();
+            const component = setUp();
+            expect(component.find(SingleAttributeContext.Provider).prop('value').page).toBe(0);
+
+            act(() => {
+                component.find(SingleAttributeContext.Provider).prop('value').setPage(1);
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.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,
+                searchQuery: '',
+                globalFilter: '',
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 15,
+                options: undefined
+            });
+        });
+
+        it('setSearchQuery should work correctly', () => {
+            const store = mockStore();
+            const component = setUp();
+            expect(component.find(SingleAttributeContext.Provider).prop('value').searchQuery).toBe('');
+
+            act(() => {
+                component.find(SingleAttributeContext.Provider).prop('value').setSearchQuery('query');
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.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: '',
+                sorting: undefined,
+                options: undefined
+            });
+        });
+
+        it('setShowInactiveValues should work correctly', () => {
+            const store = mockStore();
+            const component = setUp();
+            expect(component.find(SingleAttributeContext.Provider).prop('value').showInactive).toBe(false);
+
+            act(() => {
+                component.find(SingleAttributeContext.Provider).prop('value').toggleShowInactive(true);
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.Provider).prop('value').showInactive).toBe(true);
+
+            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,
+                searchQuery: '',
+                globalFilter: '',
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                options: ''
+            });
+        });
+
+        it('should use the value from the entity', async () => {
+            const store = mockStore();
+            const values = [
+                {uri: '1', value: '1'},
+                {uri: '2', value: 'loadedValue'}
+            ];
+            const attributeUri = 'configuration/entityTypes/HCP/attributes/TestAttribute';
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    TestAttribute: values,
+                    paging: {
+                        [attributeUri]: {
+                            totalOvValues: 1
+                        }
+                    }
+                }
+            });
+
+            const component = setUp({
+                attributeUri
+            } as SingleAttributeViewConfig);
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                values: []
+            });
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                values: [values[0], store.profile.entity.attributes.TestAttribute[0]]
+            });
+            expect(dispatch).toHaveBeenCalledWith(
+                profile.actions.processNextPageOfAttributeValues({
+                    parentUri: store.profile.entity.uri,
+                    attributeTypeUri: attributeUri,
+                    attributeTypeName: 'TestAttribute',
+                    values
+                })
+            );
+        });
+
+        it('should switch to history correctly', async () => {
+            const store = mockStore();
+            const values = [{uri: '1', value: '1'}];
+            (getPagedEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: values,
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalValues: 1
+                        }
+                    }
+                }
+            });
+
+            const component = setUp();
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: true,
+                page: 0,
+                values: []
+            });
+
+            expect(getPagedEntity).toHaveBeenCalled();
+
+            await act(async () => {
+                await Promise.resolve();
+            });
+
+            component.update();
+            expect(component.find(SingleAttributeContext.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: 'Address',
+                    values
+                })
+            );
+
+            //switch to history
+            const history = {
+                slice: {aEntity: {uri: 'entity/entityUri'}, bEntity: {a: 1}},
+                diff: {
+                    attributes: {
+                        TestAttribute: [{uri: '3', value: 'newValue'}]
+                    },
+                    roles: [],
+                    tags: []
+                }
+            };
+            mockStore(createStore(false, false, history));
+            (getPagedLocalEntity as jest.Mock).mockResolvedValue({
+                attributes: {
+                    Address: ['VALUE 1', 'VALUE 2'],
+                    paging: {
+                        'configuration/entityTypes/HCP/attributes/Address': {
+                            totalOvValues: 2,
+                            totalValues: 2
+                        }
+                    }
+                }
+            });
+
+            component.setProps({});
+            await act(async () => {
+                await Promise.resolve();
+            });
+            component.update();
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 2,
+                values: ['VALUE 1', 'VALUE 2']
+            });
+
+            expect(getPagedLocalEntity).toHaveBeenCalledWith({
+                metadata: store.metadata.knest,
+                entity: {
+                    ...history.slice.aEntity,
+                    ...history.diff
+                },
+                apiPath: store.ui.paths.apiPath,
+                tenant: store.tenant.id,
+                parentUri: history.slice.aEntity.uri,
+                defaultMaxValues: 15,
+                searchQuery: '',
+                globalFilter: '',
+                attributeTypeUri: defaultConfig.attributeUri,
+                offset: 0,
+                options: undefined
+            });
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                isLoading: false,
+                page: 0,
+                totalVisibleValues: 2,
+                values: ['VALUE 1', 'VALUE 2']
+            });
+        });
+
+        it('should provide nonVisibleValues which contain ov false values', async () => {
+            const store = mockStore();
+            const attributeUri = 'configuration/entityTypes/HCP/attributes/TestAttribute';
+
+            const component = setUp({
+                attributeUri
+            } as SingleAttributeViewConfig);
+
+            expect(component.find(SingleAttributeContext.Provider).prop('value')).toMatchObject({
+                nonVisibleValues: [store.profile.entity.attributes.TestAttribute[1]]
+            });
+        });
+    });
+
+    it('should provide className to SingleAttributeView component', () => {
+        const className = 'TestClassname';
+        mockStore();
+        const component = setUp(defaultConfig, className);
+        expect(component.find(SingleAttributeView).prop('className')).toBe(className);
+    });
+});