@reltio/profile 1.4.1585 → 1.4.1586-mui5

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

@@ -0,0 +1,431 @@
+import React from 'react';
+import {mount} from 'enzyme';
+import {act} from 'react-dom/test-utils';
+import {ViewIdContext} from '@reltio/components';
+import AttributeTable from '../AttributeTable';
+import HeadCellRenderer from '../cell-renderers/HeadCellRenderer';
+import * as reactRedux from 'react-redux';
+import {Mode, TableAttributeViewConfig} from '@reltio/mdm-sdk';
+import {TableAttributeContext} from '../../../contexts/TableAttributeContext';
+import DefaultCellValueRenderer from '../cell-renderers/DefaultCellValueRenderer';
+
+const expectedTableColumnData = [
+    {
+        id: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+        label: 'FirstLevelNestedSub1_HCP',
+        headCellRenderer: HeadCellRenderer,
+        rowCellValueRenderer: DefaultCellValueRenderer,
+        dataTypeDefinition: {
+            type: 'DependentLookup',
+            uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+            dependentLookupCode: 'LANG_CD'
+        },
+        sortable: true,
+        resizable: true,
+        nestedPath: null
+    },
+    {
+        id: 'attributes.FirstLevelNested.SecondLevelNested.Country',
+        label: 'Country_HCP',
+        headCellRenderer: HeadCellRenderer,
+        rowCellValueRenderer: DefaultCellValueRenderer,
+        dataTypeDefinition: {
+            type: 'DependentLookup',
+            uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/SecondLevelNested/attributes/Country',
+            dependentLookupCode: 'Use case 1 - Country Code'
+        },
+        sortable: true,
+        resizable: true,
+        nestedPath: ['SecondLevelNested']
+    }
+];
+
+const expectedTableRowsData = [
+    {
+        'attributes.FirstLevelNested.FirstLevelNestedSub1': [
+            {
+                value: 'Gujarati',
+                lookupCode: 'guj',
+                uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/FirstLevelNestedSub1/3YrwSnHs4'
+            }
+        ],
+        'attributes.FirstLevelNested.SecondLevelNested.Country': [
+            [
+                {
+                    value: 'Küçükçekmece',
+                    lookupCode: 'Küçükç',
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/4AgJ5h9tG/Country/4AgJ5hE9W'
+                }
+            ],
+            [
+                {
+                    value: 'France',
+                    lookupCode: 'FR',
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/3YrwSm7Pg/Country/3YrwSmwYm'
+                }
+            ]
+        ],
+        value: {
+            label: 'Gujarati',
+            value: {
+                FirstLevelNestedSub1: [
+                    {
+                        type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+                        ov: true,
+                        value: 'Gujarati',
+                        lookupCode: 'guj',
+                        lookupRawValue: 'guj',
+                        uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/FirstLevelNestedSub1/3YrwSnHs4'
+                    }
+                ],
+                SecondLevelNested: [
+                    {
+                        label: '',
+                        value: {
+                            Country: [
+                                {
+                                    type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/SecondLevelNested/attributes/Country',
+                                    ov: true,
+                                    value: 'Küçükçekmece',
+                                    lookupCode: 'Küçükç',
+                                    lookupRawValue: 'Küçükç',
+                                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/4AgJ5h9tG/Country/4AgJ5hE9W'
+                                }
+                            ]
+                        },
+                        ov: true,
+                        uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/4AgJ5h9tG'
+                    },
+                    {
+                        label: 'VOCO',
+                        value: {
+                            Country: [
+                                {
+                                    type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/SecondLevelNested/attributes/Country',
+                                    ov: true,
+                                    value: 'France',
+                                    lookupCode: 'FR',
+                                    lookupRawValue: 'FR',
+                                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/3YrwSm7Pg/Country/3YrwSmwYm'
+                                }
+                            ]
+                        },
+                        ov: true,
+                        uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/3YrwSm7Pg'
+                    }
+                ]
+            },
+            ov: true,
+            uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q'
+        }
+    }
+];
+
+const values = [
+    {
+        label: 'Gujarati',
+        value: {
+            FirstLevelNestedSub1: [
+                {
+                    type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+                    ov: true,
+                    value: 'Gujarati',
+                    lookupCode: 'guj',
+                    lookupRawValue: 'guj',
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/FirstLevelNestedSub1/3YrwSnHs4'
+                }
+            ],
+            SecondLevelNested: [
+                {
+                    label: '',
+                    value: {
+                        Country: [
+                            {
+                                type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/SecondLevelNested/attributes/Country',
+                                ov: true,
+                                value: 'Küçükçekmece',
+                                lookupCode: 'Küçükç',
+                                lookupRawValue: 'Küçükç',
+                                uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/4AgJ5h9tG/Country/4AgJ5hE9W'
+                            }
+                        ]
+                    },
+                    ov: true,
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/4AgJ5h9tG'
+                },
+                {
+                    label: 'VOCO',
+                    value: {
+                        Country: [
+                            {
+                                type: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/SecondLevelNested/attributes/Country',
+                                ov: true,
+                                value: 'France',
+                                lookupCode: 'FR',
+                                lookupRawValue: 'FR',
+                                uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/3YrwSm7Pg/Country/3YrwSmwYm'
+                            }
+                        ]
+                    },
+                    ov: true,
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q/SecondLevelNested/3YrwSm7Pg'
+                }
+            ]
+        },
+        ov: true,
+        uri: 'entities/mnGg0XB/attributes/FirstLevelNested/3YrwSm39Q'
+    }
+];
+
+const columnsData = [
+    {
+        id: 'attributes.FirstLevelNested.FirstLevelNestedSub1',
+        label: 'FirstLevelNestedSub1_HCP',
+        dataTypeDefinition: {
+            type: 'DependentLookup',
+            uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/FirstLevelNestedSub1',
+            dependentLookupCode: 'LANG_CD'
+        }
+    },
+    {
+        id: 'attributes.FirstLevelNested.SecondLevelNested.Country',
+        label: 'Country_HCP',
+        dataTypeDefinition: {
+            type: 'DependentLookup',
+            uri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested/attributes/SecondLevelNested/attributes/Country',
+            dependentLookupCode: 'Use case 1 - Country Code'
+        }
+    }
+];
+
+const config = {
+    attributeUri: 'configuration/entityTypes/HCP/attributes/FirstLevelNested',
+    caption: 'Attributes View',
+    max: 15
+} as TableAttributeViewConfig;
+
+const props = {
+    columnsData,
+    values,
+    sorting: {
+        field: 'attributes.FirstLevelNested.SecondLevelNested.Country',
+        order: 'asc'
+    },
+    onFilter: jest.fn(),
+    filters: {
+        'attributes.FirstLevelNested.SecondLevelNested.Country': {
+            filter: 'equal',
+            value: 'FR'
+        }
+    },
+    onSort: jest.fn(),
+    metadata: {
+        uri: 'uri',
+        description: 'desc',
+        label: 'label',
+        schemaVersion: 'scheme'
+    },
+    config,
+    deletedUris: []
+};
+
+const setUp = (props) =>
+    mount(
+        <ViewIdContext.Provider value={config.id}>
+            <TableAttributeContext.Provider
+                value={{
+                    attributeType: {
+                        name: 'ContactPreference',
+                        type: 'Nested',
+                        uri: 'configuration/entityTypes/HCA/attributes/ContactPreference'
+                    },
+                    hasPaging: false,
+                    searchQuery: '',
+                    setSearchQuery: () => {},
+                    values: [],
+                    page: 0,
+                    setPage: () => {},
+                    sorting: {order: 'desc', field: 'field'},
+                    onToggleFilters: () => {},
+                    onSort: () => {},
+                    onFilter: () => {},
+                    onChangeColumns: () => {},
+                    isLoading: false,
+                    filters: {},
+                    visibleColumns: [],
+                    totalVisibleValues: 4,
+                    showTable: true,
+                    allColumnsData: []
+                }}
+            >
+                <AttributeTable {...props} />
+            </TableAttributeContext.Provider>
+        </ViewIdContext.Provider>
+    );
+
+const createStore = (mode = Mode.Viewing) => {
+    return {
+        profile: {
+            mode,
+            entity: {
+                uri: 'entities/16U22HKn'
+            },
+            modifiedEntities: {
+                'entities/16U22HKn': {
+                    uri: 'entities/16U22HKn',
+                    type: 'configuration/entityTypes/HCA',
+                    attributes: {
+                        FirstLevelNested: []
+                    }
+                }
+            }
+        },
+        user: {
+            roles: []
+        }
+    };
+};
+
+const mockStore = (store = createStore()) => {
+    jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(store));
+    jest.spyOn(reactRedux, 'useDispatch').mockImplementation(jest.fn());
+};
+
+const BasicTable = () => null;
+
+jest.mock('@reltio/components', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/components'),
+    BasicTable
+}));
+
+describe('AttributeTable', () => {
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should pass correct props to BasicTable', () => {
+        mockStore();
+        const component = setUp(props);
+        expect(component.find(BasicTable).prop('rowsData')).toEqual(expectedTableRowsData);
+        expect(component.find(BasicTable).prop('columnsData')).toEqual(expectedTableColumnData);
+        expect(component.find(BasicTable).prop('sorting')).toEqual(props.sorting);
+        expect(component.find(BasicTable).prop('onSort')).toEqual(props.onSort);
+        expect(component.find(BasicTable).prop('onFilter')).toEqual(props.onFilter);
+        expect(component.find(BasicTable).prop('filters')).toEqual(props.filters);
+    });
+
+    it('should hover row', () => {
+        mockStore();
+        const component = setUp(props);
+        expect(component.find(BasicTable).prop('hoverRowIndex')).toBeNull();
+        act(() => {
+            component.find(BasicTable).prop('onRowHover')(0);
+        });
+        component.update();
+
+        expect(component.find(BasicTable).prop('hoverRowIndex')).toBe(0);
+    });
+
+    it('should not have hoveredRowRightContent if reading mode', () => {
+        mockStore();
+        const component = setUp(props);
+        expect(component.find(BasicTable).prop('hoveredRowRightContent')).toBe(undefined);
+    });
+
+    it('should have hoveredRowRightContent if edited mode', () => {
+        mockStore(createStore(Mode.Editing));
+        const component = setUp(props);
+        const onRowHover = component.find(BasicTable).prop('onRowHover');
+        act(() => {
+            onRowHover(0);
+        });
+        act(() => {
+            component.update();
+        });
+        const hoverRowIndex = component.find(BasicTable).prop('hoverRowIndex');
+        expect(hoverRowIndex).toBe(0);
+        expect(component.find(BasicTable).prop('hoveredRowRightContent')).toBeDefined();
+    });
+
+    it('should pass deletedUris to BasicTable context', () => {
+        mockStore(createStore(Mode.Editing));
+        const deletedUris = ['deleted1', 'deleted2'];
+        const component = setUp({...props, deletedUris});
+        expect(component.find(BasicTable).prop('context')).toEqual({deletedUris});
+    });
+
+    it('should not show hoveredRowRightContent if attribute is deleted', () => {
+        mockStore(createStore(Mode.Editing));
+        const component = setUp({
+            ...props,
+            values: [
+                {
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/deletedUri',
+                    ov: true,
+                    label: 'Gujarati',
+                    value: {
+                        SecondLevelNested: [],
+                        FirstLevelNestedSub1: []
+                    }
+                },
+                {
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/notDeletedUri',
+                    ov: true,
+                    label: 'Gujarati2',
+                    value: {
+                        SecondLevelNested: [],
+                        FirstLevelNestedSub1: []
+                    }
+                }
+            ],
+            deletedUris: ['entities/mnGg0XB/attributes/FirstLevelNested/deletedUri']
+        });
+        expect(component.find(BasicTable)).toHaveLength(1);
+        const setHoverRowIndex = component.find(BasicTable).prop('onRowHover');
+        setHoverRowIndex(1);
+        act(() => {
+            component.update();
+        });
+        expect(component.find(BasicTable).prop('hoverRowIndex')).toBe(1);
+        expect(component.find(BasicTable).prop('hoveredRowRightContent')).toBeDefined();
+        setHoverRowIndex(0);
+        act(() => {
+            component.update();
+        });
+        expect(component.find(BasicTable).prop('hoverRowIndex')).toBe(0);
+        expect(component.find(BasicTable).prop('hoveredRowRightContent')).not.toBeDefined();
+    });
+
+    it('should not show hoveredRowRightContent in reading mode', () => {
+        mockStore();
+        const component = setUp({
+            ...props,
+            values: [
+                {
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/deletedUri',
+                    ov: true,
+                    label: 'Gujarati',
+                    value: {
+                        SecondLevelNested: [],
+                        FirstLevelNestedSub1: []
+                    }
+                },
+                {
+                    uri: 'entities/mnGg0XB/attributes/FirstLevelNested/notDeletedUri',
+                    ov: true,
+                    label: 'Gujarati2',
+                    value: {
+                        SecondLevelNested: [],
+                        FirstLevelNestedSub1: []
+                    }
+                }
+            ],
+            deletedUris: []
+        });
+        expect(component.find(BasicTable)).toHaveLength(1);
+        const setHoverRowIndex = component.find(BasicTable).prop('onRowHover');
+        setHoverRowIndex(1);
+        component.update();
+        expect(component.find(BasicTable).prop('hoverRowIndex')).toBe(1);
+        expect(component.find(BasicTable).prop('hoveredRowRightContent')).not.toBeDefined();
+    });
+});

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

@@ -0,0 +1,54 @@
+import EditButtons from '../EditButtons';
+import React from 'react';
+import {shallow} from 'enzyme';
+import {act} from 'react-dom/test-utils';
+import {SmallIconButtonWithTooltip} from '@reltio/components';
+import EditIcon from '@mui/icons-material/Edit';
+import DeleteIcon from '@mui/icons-material/Delete';
+
+const setUp = (props) => shallow(<EditButtons {...props} />);
+
+describe('EditButtons', () => {
+    it('should render EditIcon and deleteIcon if canUpdate and canRemove props passed', () => {
+        const component = setUp({onEdit: jest.fn(), onRemove: jest.fn()});
+        expect(component.find(SmallIconButtonWithTooltip)).toHaveLength(2);
+    });
+
+    it('should not render buttons if no props passed', () => {
+        const component = setUp({});
+        expect(component.find(SmallIconButtonWithTooltip)).toHaveLength(0);
+    });
+
+    it('should call onEdit, onRemove props on click icons edit and delete', () => {
+        const onEdit = jest.fn();
+        const onRemove = jest.fn();
+        const component = setUp({onEdit, onRemove});
+        expect(component.find(SmallIconButtonWithTooltip)).toHaveLength(2);
+        const editButton = component.find(SmallIconButtonWithTooltip).at(0);
+        const removeButton = component.find(SmallIconButtonWithTooltip).at(1);
+        expect(onEdit).not.toHaveBeenCalled();
+        act(() => {
+            editButton.simulate('click');
+        });
+        expect(onEdit).toHaveBeenCalledTimes(1);
+        expect(onRemove).not.toHaveBeenCalled();
+        act(() => {
+            removeButton.simulate('click');
+        });
+        expect(onRemove).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not render delete button if onRemove not passed', () => {
+        const onEdit = jest.fn();
+        const component = setUp({onEdit});
+        expect(component.find(SmallIconButtonWithTooltip)).toHaveLength(1);
+        expect(component.find(SmallIconButtonWithTooltip).prop('icon')).toBe(EditIcon);
+    });
+
+    it('should not render delete button if onEdit not passed', () => {
+        const onRemove = jest.fn();
+        const component = setUp({onRemove});
+        expect(component.find(SmallIconButtonWithTooltip)).toHaveLength(1);
+        expect(component.find(SmallIconButtonWithTooltip).prop('icon')).toBe(DeleteIcon);
+    });
+});

package/src/components/ProfileTableAttributeView/components/AttributeTable/cell-renderers/BlobRenderer.tsx

@@ -0,0 +1,20 @@
+import React from 'react';
+import {stopPropagation} from '@reltio/components';
+import {PrimitiveValue} from '@reltio/mdm-sdk';
+import {useStyles} from './styles';
+
+type Props = {
+    value: PrimitiveValue;
+    historyClassName?: string;
+};
+
+const BlobRenderer = ({value, historyClassName}: Props) => {
+    const styles = useStyles();
+    return (
+        <div className={styles.blobWrapper} onScroll={stopPropagation}>
+            <span className={styles[historyClassName]}>{value}</span>
+        </div>
+    );
+};
+
+export default BlobRenderer;

package/src/components/ProfileTableAttributeView/components/AttributeTable/cell-renderers/DefaultCellValueRenderer.tsx

@@ -0,0 +1,43 @@
+import React, {useContext} from 'react';
+import {pipe} from 'ramda';
+import {DataTypes, getHistoryAppearanceByUri, getHistoryAttributeClassName, PrimitiveValue} from '@reltio/mdm-sdk';
+import {DataTypeValue, ExpandedValueTooltip, HistoryDiffContext} from '@reltio/components';
+import BlobRenderer from './BlobRenderer';
+import {useStyles} from './styles';
+
+type Props = {
+    value: {
+        value: PrimitiveValue;
+        uri: string;
+    };
+    columnData: {
+        dataTypeDefinition: {
+            type: DataTypes;
+        };
+    };
+};
+
+const DefaultCellValueRenderer = ({value, columnData: {dataTypeDefinition}}: Props) => {
+    const styles = useStyles();
+
+    const {value: simpleValue, uri} = value;
+    const {appearance} = useContext(HistoryDiffContext);
+    const historyClassName = pipe(getHistoryAppearanceByUri, getHistoryAttributeClassName)(uri, appearance);
+
+    switch (dataTypeDefinition.type) {
+        case DataTypes.TYPE_BLOB:
+            return <BlobRenderer value={simpleValue} historyClassName={historyClassName} />;
+        default: {
+            const dataTypeValue = <DataTypeValue value={simpleValue} dataTypeDefinition={dataTypeDefinition} />;
+            return (
+                <ExpandedValueTooltip value={dataTypeValue}>
+                    <div className={styles.defaultWrapper}>
+                        <span className={styles[historyClassName]}>{dataTypeValue}</span>
+                    </div>
+                </ExpandedValueTooltip>
+            );
+        }
+    }
+};
+
+export default DefaultCellValueRenderer;

package/src/components/ProfileTableAttributeView/components/AttributeTable/cell-renderers/HeadCellRenderer.tsx

@@ -0,0 +1,19 @@
+import React from 'react';
+
+import DefaultHeadCellRenderer from 'react-components/dist/Table/DefaultHeadCellRenderer/DefaultHeadCellRenderer';
+import {withFilterAtBottom, DescriptionIcon} from '@reltio/components';
+import {useStyles} from './styles';
+
+const HeadCellRenderer = (props) => {
+    const styles = useStyles();
+    const {description} = props?.headCellData || {};
+
+    return (
+        <div className={styles.headCell}>
+            <DefaultHeadCellRenderer {...props} />
+            <DescriptionIcon description={description} className={styles.description} />
+        </div>
+    );
+};
+
+export default withFilterAtBottom(HeadCellRenderer);

package/src/components/ProfileTableAttributeView/components/AttributeTable/cell-renderers/RowCellRenderer.tsx

@@ -0,0 +1,33 @@
+import React from 'react';
+import classnames from 'classnames';
+import {useStyles} from './styles';
+import {withTableContext} from '@reltio/components';
+
+type Props = {
+    cell: {values: string[]};
+    isSorted: boolean;
+    CellValueRenderer: React.ElementType;
+    isRemoved: boolean;
+};
+const RowCellRenderer = ({cell, CellValueRenderer, isRemoved, isSorted, ...otherProps}: Props) => {
+    const styles = useStyles();
+    return (
+        <div
+            className={classnames(
+                {
+                    [styles['row-cell--sorted']]: isSorted,
+                    [styles['row-cell--removed']]: isRemoved
+                },
+                styles.rowCell
+            )}
+        >
+            {cell.values.map((value, index) => (
+                <CellValueRenderer key={index} value={value} {...otherProps} />
+            ))}
+        </div>
+    );
+};
+
+export default withTableContext(({deletedUris}, {rowValue: {value}}) => ({
+    isRemoved: Boolean(deletedUris.find((uri) => value.uri === uri))
+}))(RowCellRenderer);

package/src/components/ProfileTableAttributeView/components/AttributeTable/cell-renderers/__tests__/BlobRenderer.test.tsx

@@ -0,0 +1,29 @@
+import {shallow} from 'enzyme';
+import React from 'react';
+import BlobRenderer from '../BlobRenderer';
+
+describe('BlobRenderer tests', () => {
+    const value = 'test Value';
+    it('should render correctly', () => {
+        const wrapper = shallow(<BlobRenderer value={value} />);
+        expect(wrapper.text()).toContain(value);
+        expect(wrapper.find('span').hasClass('updateAttribute')).toBe(false);
+        expect(wrapper.find('span').hasClass('insertAttribute')).toBe(false);
+        expect(wrapper.find('span').hasClass('deleteAttribute')).toBe(false);
+    });
+
+    it('should add updateAttribute class name if historyClassName is updateAttribute', () => {
+        const wrapper = shallow(<BlobRenderer value={value} historyClassName={'updateAttribute'} />);
+        expect(wrapper.find('span').hasClass('updateAttribute')).toBe(true);
+    });
+
+    it('should add insertAttribute class name if historyClassName is insertAttribute', () => {
+        const wrapper = shallow(<BlobRenderer value={value} historyClassName={'insertAttribute'} />);
+        expect(wrapper.find('span').hasClass('insertAttribute')).toBe(true);
+    });
+
+    it('should add deleteAttribute class name if historyClassName is deleteAttribute', () => {
+        const wrapper = shallow(<BlobRenderer value={value} historyClassName={'deleteAttribute'} />);
+        expect(wrapper.find('span').hasClass('deleteAttribute')).toBe(true);
+    });
+});