Loading...
+ )
+}));
+
+jest.mock('@utils/Utils', () => ({
+ isArray: (value: any) => Array.isArray(value),
+ isEmpty: (value: any) => {
+ if (value === null || value === undefined) return true;
+ if (typeof value === 'string') return value.trim() === '';
+ if (Array.isArray(value)) return value.length === 0;
+ if (typeof value === 'object') return Object.keys(value).length === 0;
+ return false;
+ },
+ pick: (obj: any, keys: string[]) => {
+ const result: any = {};
+ keys.forEach(key => {
+ if (obj && key in obj) {
+ result[key] = obj[key];
+ }
+ });
+ return result;
+ }
+}));
+
+jest.mock('@components/muiComponents', () => ({
+ Accordion: ({ children, defaultExpanded }: any) => (
+ = {}) =>
+ render(
+
+
+ ,
+ )
+
+ it('renders entity title and short + long description', () => {
+ renderComp()
+ const heading = screen.getByRole('heading', { level: 1 })
+ expect(heading).toHaveTextContent('Atlas Entity One')
+ expect(screen.getByText('Short Description')).toBeInTheDocument()
+ expect(
+ screen.getByTestId('smt-plain').textContent?.includes('short-one'),
+ ).toBe(true)
+ expect(screen.getByText(/Long Description/)).toBeInTheDocument()
+ expect(screen.getByTestId('smt-html').textContent).toContain('san(')
+ })
+
+ it('omits short description block when undefined', () => {
+ renderComp({ shortDescription: undefined })
+ expect(screen.queryByText('Short Description')).toBeNull()
+ expect(screen.getByText(/Description/)).toBeInTheDocument()
+ })
+
+ it('shows N/A when short description empty', () => {
+ renderComp({ shortDescription: '' })
+ expect(screen.getByText('N/A')).toBeInTheDocument()
+ })
+
+ const tooltipIconClick = (label: string): void => {
+ const wrap = document.querySelector(`[data-title="${label}"]`) as HTMLElement | null
+ if (!wrap) {
+ throw new Error(`missing tooltip: ${label}`)
+ }
+ const target =
+ (wrap.querySelector('.MuiIconButton-root') as HTMLElement | null) ??
+ (wrap.querySelector('button') as HTMLElement | null)
+ if (!target) {
+ throw new Error(`no icon in tooltip: ${label}`)
+ }
+ fireEvent.click(target)
+ }
+
+ it('plain toggle swaps long description variant', () => {
+ renderComp()
+ fireEvent.click(screen.getByRole('button', { name: 'Plain' }))
+ expect(screen.getAllByTestId('smt-plain').length).toBeGreaterThan(0)
+ fireEvent.click(screen.getByRole('button', { name: 'Formatted' }))
+ expect(screen.getByTestId('smt-html')).toBeInTheDocument()
+ })
+
+ it('edit classification opens tag modal when tagName set', () => {
+ mockParams.tagName = 'mytag'
+ renderComp()
+ const addTagBtn = document.querySelector('[data-cy="addTag"]') as HTMLElement
+ fireEvent.click(addTagBtn)
+ expect(screen.getByTestId('classification-form')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-cf'))
+ })
+
+ it('edit opens term form when gtype term and guid set', () => {
+ mockGtype = 'term'
+ mockParams.guid = 'g-term'
+ renderComp()
+ const addTagBtn = document.querySelector('[data-cy="addTag"]') as HTMLElement
+ fireEvent.click(addTagBtn)
+ expect(screen.getByTestId('edit-term')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-term'))
+ })
+
+ it('edit opens category form when gtype category', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'g-cat'
+ renderComp()
+ const addTagBtn = document.querySelector('[data-cy="addTag"]') as HTMLElement
+ fireEvent.click(addTagBtn)
+ expect(screen.getByTestId('edit-category')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-category'))
+ })
+
+ it('hides edit button when bmguid present', () => {
+ mockParams.bmguid = 'bm-1'
+ renderComp()
+ expect(document.querySelector('[data-cy="addTag"]')).toBeNull()
+ })
+
+ it('shows classifications for term gtype when loaded', () => {
+ mockGtype = 'term'
+ renderComp()
+ expect(screen.getByTestId('smv-Classifications')).toBeInTheDocument()
+ tooltipIconClick('Add Classifications')
+ expect(screen.getByTestId('add-tag')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-tag'))
+ })
+
+ it('shows skeleton for classifications while loading', () => {
+ mockGtype = 'term'
+ renderComp({ loading: true })
+ const loaders = screen.getAllByTestId('skeleton')
+ expect(loaders.length).toBeGreaterThan(0)
+ })
+
+ it('category page shows terms and assign term flow', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ renderComp()
+ expect(screen.getByTestId('smv-Terms')).toBeInTheDocument()
+ tooltipIconClick('Add Term')
+ expect(screen.getByTestId('assign-term')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-assign-term'))
+ })
+
+ it('toast when no glossary terms available for assign term', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ mockUseAppSelector.mockImplementation((fn: (s: unknown) => unknown) =>
+ fn({
+ glossary: {
+ glossaryData: [{ terms: [] }],
+ },
+ }),
+ )
+ renderComp()
+ tooltipIconClick('Add Term')
+ expect(mockToast.info).toHaveBeenCalledWith('There are no available terms')
+ expect(screen.queryByTestId('assign-term')).toBeNull()
+ })
+
+ it('term page shows categories and assign category', () => {
+ mockGtype = 'term'
+ mockParams.guid = 'gt'
+ renderComp()
+ expect(screen.getByTestId('smv-Category')).toBeInTheDocument()
+ tooltipIconClick('Add Categories')
+ expect(screen.getByTestId('assign-category')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-assign-cat'))
+ })
+
+ it('superTypes section loading and loaded', () => {
+ const { rerender } = render(
+
+
+ ,
+ )
+ expect(screen.getAllByTestId('skeleton').length).toBeGreaterThan(0)
+ rerender(
+
+
+ ,
+ )
+ expect(screen.getByText('Direct super-classifications')).toBeInTheDocument()
+ expect(screen.getByTestId('smv-Super Classifications')).toBeInTheDocument()
+ })
+
+ it('subTypes section loading and loaded', () => {
+ const { rerender } = render(
+
+
+ ,
+ )
+ expect(screen.getAllByTestId('skeleton').length).toBeGreaterThan(0)
+ rerender(
+
+
+ ,
+ )
+ expect(screen.getByText('Direct sub-classifications')).toBeInTheDocument()
+ expect(screen.getByTestId('smv-Sub Classifications')).toBeInTheDocument()
+ })
+
+ it('attribute defs section and add attributes modal', () => {
+ renderComp()
+ expect(screen.getByText(/Attributes/)).toBeInTheDocument()
+ expect(screen.getByTestId('smv-Atrributes')).toBeInTheDocument()
+ tooltipIconClick('Add Attributes')
+ expect(screen.getByTestId('add-attrs')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-attrs'))
+ })
+
+ it('attribute defs loading shows skeleton', () => {
+ renderComp({ loading: true, attributeDefs: [{}] })
+ expect(screen.getAllByTestId('skeleton').length).toBeGreaterThan(0)
+ })
+
+ it('getDescriptionForDisplay via object shape description', () => {
+ renderComp({ description: { k: 'inner' } })
+ expect(screen.getByTestId('smt-html').textContent).toContain('san(inner)')
+ })
+
+ it('description object without string values uses empty string path', () => {
+ renderComp({ description: { a: 1, b: 2 } })
+ expect(screen.getByTestId('smt-html').textContent).toContain('san()')
+ })
+
+ it('getDescriptionForDisplay returns empty for numeric description', () => {
+ renderComp({ description: 42 })
+ expect(screen.getByTestId('smt-html').textContent).toContain('san()')
+ })
+
+ it('getDescriptionForDisplay returns empty for array description', () => {
+ renderComp({ description: ['x'] })
+ expect(screen.getByTestId('smt-html').textContent).toContain('san()')
+ })
+
+ it('getDescriptionForDisplay returns empty for undefined description', () => {
+ renderComp({ description: undefined })
+ expect(screen.getByTestId('smt-html').textContent).toContain('san()')
+ })
+
+ it('category Terms section shows skeleton while loading', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ renderComp({ loading: true })
+ expect(screen.getAllByTestId('skeleton').length).toBeGreaterThan(0)
+ expect(screen.queryByTestId('smv-Terms')).toBeNull()
+ })
+
+ it('term Categories section hidden when guid is empty and not loading', () => {
+ mockGtype = 'term'
+ mockParams.guid = ''
+ renderComp({ loading: false })
+ expect(screen.queryByTestId('smv-Category')).toBeNull()
+ })
+
+ it('treats hasAnyGlossaryTerms as false when glossaryData is not an array', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ mockUseAppSelector.mockImplementation((fn: (s: unknown) => unknown) =>
+ fn({
+ glossary: {
+ glossaryData: { terms: [{ id: 't1' }] },
+ },
+ }),
+ )
+ renderComp()
+ tooltipIconClick('Add Term')
+ expect(mockToast.info).toHaveBeenCalledWith('There are no available terms')
+ })
+
+ it('omits Attributes block when attributeDefs is undefined', () => {
+ renderComp({ attributeDefs: undefined })
+ expect(screen.queryByText(/Attributes:/)).toBeNull()
+ expect(screen.queryByTestId('smv-Atrributes')).toBeNull()
+ })
+
+ it('uses empty lists when data is null for optional ShowMore paths', () => {
+ mockGtype = 'term'
+ mockParams.guid = 'g1'
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: [],
+ })
+ expect(screen.getByTestId('smv-Classifications')).toBeInTheDocument()
+ })
+
+ it('category Terms list tolerates null entity data via optional chaining', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: [],
+ })
+ expect(screen.getByTestId('smv-Terms')).toBeInTheDocument()
+ })
+
+ it('term Categories list tolerates null entity data via optional chaining', () => {
+ mockGtype = 'term'
+ mockParams.guid = 'gt'
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: [],
+ })
+ expect(screen.getByTestId('smv-Category')).toBeInTheDocument()
+ })
+
+ it('Sub Classifications ShowMore tolerates null entity data', () => {
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: ['s'],
+ loading: false,
+ })
+ expect(screen.getByTestId('smv-Sub Classifications')).toBeInTheDocument()
+ })
+
+ it('Attributes ShowMore tolerates null entity data', () => {
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: [],
+ attributeDefs: [{}],
+ loading: false,
+ })
+ expect(screen.getByTestId('smv-Atrributes')).toBeInTheDocument()
+ })
+
+ it('uses empty superTypes list when data omits superTypes key', () => {
+ renderComp({
+ data: {
+ name: 'OnlyName',
+ classifications: [],
+ terms: [],
+ categories: [],
+ subTypes: [{ z: 1 }],
+ attributeDefs: [],
+ },
+ superTypes: ['trigger'],
+ subTypes: [],
+ loading: false,
+ })
+ expect(screen.getByTestId('smv-Super Classifications')).toBeInTheDocument()
+ })
+
+ it('hasAnyGlossaryTerms is false when glossary entry terms is not an array', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ mockUseAppSelector.mockImplementation((fn: (s: unknown) => unknown) =>
+ fn({
+ glossary: {
+ glossaryData: [{ terms: 'not-array' }],
+ },
+ }),
+ )
+ renderComp()
+ tooltipIconClick('Add Term')
+ expect(mockToast.info).toHaveBeenCalledWith('There are no available terms')
+ })
+
+ it('hasAnyGlossaryTerms skips null glossary rows then finds terms', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ mockUseAppSelector.mockImplementation((fn: (s: unknown) => unknown) =>
+ fn({
+ glossary: {
+ glossaryData: [null, { terms: [{ id: 't1' }] }],
+ },
+ }),
+ )
+ renderComp()
+ tooltipIconClick('Add Term')
+ expect(screen.getByTestId('assign-term')).toBeInTheDocument()
+ fireEvent.click(screen.getByText('close-assign-term'))
+ })
+
+ it('AssignTerm receives empty object when entity data is null', () => {
+ mockGtype = 'category'
+ mockParams.guid = 'gc'
+ mockUseAppSelector.mockImplementation((fn: (s: unknown) => unknown) =>
+ fn({
+ glossary: {
+ glossaryData: [{ terms: [{ id: 't1' }] }],
+ },
+ }),
+ )
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: [],
+ })
+ tooltipIconClick('Add Term')
+ expect(screen.getByTestId('assign-term').getAttribute('data-received')).toBe('{}')
+ fireEvent.click(screen.getByText('close-assign-term'))
+ })
+
+ it('AssignCategory receives empty object when entity data is null', () => {
+ mockGtype = 'term'
+ mockParams.guid = 'gt'
+ renderComp({
+ data: null,
+ superTypes: [],
+ subTypes: [],
+ })
+ tooltipIconClick('Add Categories')
+ expect(screen.getByTestId('assign-category').getAttribute('data-received')).toBe(
+ '{}',
+ )
+ fireEvent.click(screen.getByText('close-assign-cat'))
+ })
+})
diff --git a/dashboard/src/views/Glossary/__tests__/AddUpdateCategoryForm.test.tsx b/dashboard/src/views/Glossary/__tests__/AddUpdateCategoryForm.test.tsx
new file mode 100644
index 00000000000..2dc17e66a20
--- /dev/null
+++ b/dashboard/src/views/Glossary/__tests__/AddUpdateCategoryForm.test.tsx
@@ -0,0 +1,1023 @@
+/**
+ * Comprehensive unit tests for AddUpdateCategoryForm component - 100% Coverage
+ * This test suite covers all statements, branches, functions, and lines
+ */
+
+import React, { useEffect } from 'react';
+import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Provider } from 'react-redux';
+import { configureStore } from '@reduxjs/toolkit';
+import { MemoryRouter } from 'react-router-dom';
+import AddUpdateCategoryForm from '../AddUpdateCategoryForm';
+import * as glossarySlice from '@redux/slice/glossarySlice';
+import * as glossaryDetailsSlice from '@redux/slice/glossaryDetailsSlice';
+import * as detailPageSlice from '@redux/slice/detailPageSlice';
+
+// Mock functions
+const mockOnClose = jest.fn();
+const mockCreateTermorCategory = jest.fn();
+const mockEditTermorCatgeory = jest.fn();
+const mockFetchGlossaryData = jest.fn();
+const mockFetchGlossaryDetails = jest.fn();
+const mockFetchDetailPageData = jest.fn();
+const mockServerError = jest.fn();
+
+// Mock state variables
+let mockParams: { guid?: string } = {};
+let mockLocation: { search: string } = { search: '' };
+
+// Mock react-router-dom
+jest.mock('react-router-dom', () => {
+ const actual = jest.requireActual('react-router-dom');
+ return {
+ ...actual,
+ useParams: () => mockParams,
+ useLocation: () => mockLocation
+ };
+});
+
+// Mock toast
+const mockToastSuccess = jest.fn();
+const mockToastDismiss = jest.fn();
+jest.mock('react-toastify', () => ({
+ toast: {
+ success: (...args: any[]) => mockToastSuccess(...args),
+ dismiss: (...args: any[]) => mockToastDismiss(...args),
+ error: jest.fn()
+ }
+}));
+
+// Mock API methods
+jest.mock('@api/apiMethods/glossaryApiMethod', () => ({
+ createTermorCategory: (...args: any[]) => mockCreateTermorCategory(...args),
+ editTermorCatgeory: (...args: any[]) => mockEditTermorCatgeory(...args)
+}));
+
+// Mock Redux slices
+jest.mock('@redux/slice/glossarySlice', () => ({
+ fetchGlossaryData: jest.fn()
+}));
+
+jest.mock('@redux/slice/glossaryDetailsSlice', () => ({
+ fetchGlossaryDetails: jest.fn()
+}));
+
+jest.mock('@redux/slice/detailPageSlice', () => ({
+ fetchDetailPageData: jest.fn()
+}));
+
+// Mock Utils
+jest.mock('@utils/Utils', () => {
+ const actualUtils = jest.requireActual('@utils/Utils');
+ return {
+ ...actualUtils,
+ isEmpty: (value: any) => {
+ if (value === undefined || value === null) return true;
+ if (typeof value === 'object' && Object.keys(value).length === 0) return true;
+ if (typeof value === 'string' && value.trim().length === 0) return true;
+ return false;
+ },
+ serverError: (...args: any[]) => mockServerError(...args)
+ };
+});
+
+// Mock CustomModal
+jest.mock('@components/Modal', () => ({
+ __esModule: true,
+ default: ({ open, onClose, children, title, button1Handler, button2Handler, button2Label, disableButton2 }: any) =>
+ open ? (
+
+
{title}
+ {children}
+
+
+
+