@argusoft/medplat-app-shell 1.0.5 → 1.0.7

package/src/_tests_/views/components/SideBar/SideBar.test.jsx

@@ -0,0 +1,98 @@
+import { cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import SideBar from '@/layout/mainLayout/sidebar/SideBar';
+import { useNavigate } from 'react-router-dom';
+import { subGroupsMock } from '@/_tests_/views/components/SideBar/MockSideBar';
+import { customRender } from '@/common/tests/CustomWrapper';
+
+jest.mock('../../../../assets/img/training_icon.png', () => 'training-icon');
+jest.mock('../../../../assets/img/ncd_mobile.png', () => 'ncd-mobile');
+jest.mock('../../../../assets/img/fhs-icon.png', () => 'fhs-icon');
+jest.mock('../../../../assets/img/admin-icon.png', () => 'admin-icon');
+
+jest.mock('react-router', () => ({
+  ...jest.requireActual('react-router'),
+  useNavigate: jest.fn(),
+}));
+
+describe('SideBar Component', () => {
+  let mockedNavigate;
+  const renderComponent = async (params = {}) => {
+    customRender(<SideBar subGroups={subGroupsMock} />, params);
+  };
+
+  beforeEach(async () => {
+    cleanup();
+    mockedNavigate = jest.fn();
+    useNavigate.mockImplementation(() => mockedNavigate);
+    await renderComponent({ url: '/ui' });
+  });
+
+  it('should render sidebar with all menu items', async () => {
+    subGroupsMock.forEach((item) => {
+      expect(screen.getByTestId(`sidebar-listitem-${item.name}`)).toBeInTheDocument();
+    });
+  });
+
+  it('should show subgroups on hover', async () => {
+    const hoverOverSubGroups = (subGroups) => {
+      subGroups.forEach((item) => {
+        const menuItem = screen.getByTestId(`sidebar-listitem-${item.name}`);
+        fireEvent.mouseEnter(menuItem); // Hover over the menu item).toBeInTheDocument();
+
+        if (item.subGroups && item.subGroups.length > 0) {
+          expect(screen.getByTestId(`sidebar-subgroup-sidebar-${item.name}`)).toBeInTheDocument();
+          hoverOverSubGroups(item.subGroups);
+        }
+      });
+    };
+
+    hoverOverSubGroups(subGroupsMock);
+  });
+
+  it('should hide subgroups on mouse leave', async () => {
+    const menuItem = screen.getByTestId('sidebar-listitem-fhs');
+    fireEvent.mouseEnter(menuItem);
+    fireEvent.mouseLeave(menuItem);
+    expect(screen.queryByTestId('sidebar-subgroup-sidebar')).not.toBeInTheDocument();
+
+    const hoverOverSubGroups = (subGroups) => {
+      subGroups.forEach((item) => {
+        const menuItem = screen.getByTestId(`sidebar-listitem-${item.name}`);
+        fireEvent.mouseEnter(menuItem); // Hover over the menu item).toBeInTheDocument();
+
+        if (item.subGroups && item.subGroups.length > 0) {
+          const hoverSubGroup = screen.getByTestId(`sidebar-subgroup-sidebar-${item.name}`);
+          expect(hoverSubGroup).toBeInTheDocument();
+          hoverOverSubGroups(item.subGroups);
+          fireEvent.mouseLeave(menuItem);
+          expect(hoverSubGroup).not.toBeInTheDocument();
+        }
+      });
+    };
+
+    hoverOverSubGroups(subGroupsMock);
+  });
+
+  it('should render correct icons for menu items', async () => {
+    const hoverOverSubGroups = async (subGroups, hoverdSubGroup) => {
+      subGroups.forEach(async (item) => {
+        const menuItem = screen.getByTestId(`sidebar-listitem-${item.name}`);
+        fireEvent.mouseEnter(menuItem); // Hover over the menu item).toBeInTheDocument();
+
+        if (hoverdSubGroup) {
+          fireEvent.click(menuItem);
+          await waitFor(() => {
+            expect(mockedNavigate).toHaveBeenCalled();
+          });
+        }
+
+        if (item.subGroups && item.subGroups.length > 0) {
+          hoverOverSubGroups(item.subGroups, true);
+        }
+      });
+    };
+
+    hoverOverSubGroups(subGroupsMock, false);
+  });
+});

package/src/_tests_/views/components/SystemConfig/ManageSystemConfig/AddManageSystemConfig.test.jsx.disable

@@ -0,0 +1,164 @@
+import React from 'react';
+import { act, cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import { customRender } from '@/common/tests/CustomWrapper';
+import ManageSystemConfig from '@/views/feature-components/system-config/ManageSystemConfigs';
+import { useNavigate } from 'react-router';
+import { checkSystemConfigExists, postSystemConfig } from '@/common/services/SystemConfig';
+import { showToast } from '@/common/toaster/toaster';
+
+jest.mock('react-router', () => ({
+  ...jest.requireActual('react-router'),
+  useNavigate: jest.fn(),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key) => key,
+    i18n: { changeLanguage: () => new Promise(() => {}) },
+  }),
+}));
+
+jest.mock('../../../../../common/services/SystemConfig', () => ({
+  checkSystemConfigExists: jest.fn(),
+  postSystemConfig: jest.fn(),
+  getSystemConfigsByKey: jest.fn(),
+}));
+
+jest.mock('../../../../../common/toaster/toaster', () => ({
+  showToast: jest.fn(),
+}));
+
+describe('ManageSystemConfig Component', () => {
+  let mockedNavigate;
+
+  const renderComponent = async (params = {}) => {
+    customRender(<ManageSystemConfig />, params);
+  };
+
+  beforeEach(async () => {
+    cleanup();
+    mockedNavigate = jest.fn();
+    useNavigate.mockImplementation(() => mockedNavigate);
+    await renderComponent({ url: '/ui/medplat/manage/systemconfigs/managesystemconfig' });
+  });
+
+  it('should render system config form', () => {
+    const systemKeyField = screen.getByTestId('managesystemconfigs-key-field');
+    const systemValueField = screen.getByTestId('managesystemconfigs-value-field');
+    const addButton = screen.getByTestId('managesystemconfigs-submit-btn');
+    const cancelButton = screen.getByTestId('managesystemconfigs-close-btn');
+
+    expect(systemKeyField).toBeInTheDocument();
+    expect(systemKeyField.querySelector('label')).toHaveTextContent('Enter System Key');
+    expect(systemKeyField.querySelector('input')).toHaveValue('');
+
+    expect(systemValueField).toBeInTheDocument();
+    expect(systemValueField.querySelector('label')).toHaveTextContent('Key Value');
+    expect(systemValueField.querySelector('input')).toHaveValue('');
+
+    expect(addButton).toBeInTheDocument();
+    expect(addButton.querySelector('span')).toHaveTextContent('Add');
+
+    expect(cancelButton).toBeInTheDocument();
+    expect(cancelButton).toHaveTextContent('Close');
+  });
+
+  it('should render custom error if any field is empty', async () => {
+    const systemKeyField = screen.getByTestId('managesystemconfigs-key-field');
+    const systemValueField = screen.getByTestId('managesystemconfigs-value-field');
+    const addButton = screen.getByTestId('managesystemconfigs-submit-btn');
+
+    fireEvent.click(addButton);
+
+    let allErrorWarning;
+    await waitFor(() => {
+      allErrorWarning = screen.getAllByTestId('custom-error-message');
+    });
+    expect(allErrorWarning).toHaveLength(2);
+    expect(allErrorWarning[0]).toHaveTextContent('Enter System Key');
+    expect(allErrorWarning[1]).toHaveTextContent('Enter Value');
+
+    await act(async () => {
+      fireEvent.change(systemKeyField.querySelector('input'), { target: { value: 'SYSTEM_VERSION' } });
+    });
+    await waitFor(() => {
+      allErrorWarning = screen.getAllByTestId('custom-error-message');
+    });
+    expect(allErrorWarning).toHaveLength(1);
+    expect(allErrorWarning[0]).toHaveTextContent('Enter Value');
+
+    await act(async () => {
+      fireEvent.change(systemValueField.querySelector('input'), { target: { value: '0.1' } });
+    });
+    await waitFor(() => {
+      allErrorWarning = screen.queryAllByTestId('custom-error-message');
+    });
+    expect(allErrorWarning).toHaveLength(0);
+  });
+
+  it('should navigate on close button click', async () => {
+    const closeButton = screen.getByTestId('managesystemconfigs-close-btn');
+    fireEvent.click(closeButton);
+
+    expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/systemconfigs');
+  });
+
+  it('should handle successful form submission', async () => {
+    checkSystemConfigExists.mockResolvedValue({
+      data: {
+        code: 'check_if_system_configuration_exists',
+        result: [{ count: 0 }],
+        parameters: null,
+        sequence: null,
+      },
+    });
+
+    postSystemConfig.mockResolvedValue({
+      data: { success: true },
+    });
+
+    const systemKeyField = screen.getByTestId('managesystemconfigs-key-field');
+    const systemValueField = screen.getByTestId('managesystemconfigs-value-field');
+    const submitButton = screen.getByTestId('managesystemconfigs-submit-btn');
+
+    await act(async () => {
+      fireEvent.change(systemKeyField.querySelector('input'), { target: { value: 'NEW_KEY' } });
+      fireEvent.change(systemValueField.querySelector('input'), { target: { value: 'new value' } });
+      fireEvent.click(submitButton);
+    });
+
+    await waitFor(async () => {
+      expect(checkSystemConfigExists).toHaveBeenCalled();
+      expect(postSystemConfig).toHaveBeenCalled();
+    });
+  });
+
+  it('should show toast if key already exists', async () => {
+    checkSystemConfigExists.mockResolvedValue({
+      data: {
+        code: 'check_if_system_configuration_exists',
+        result: [{ count: 1 }],
+        parameters: null,
+        sequence: null,
+      },
+    });
+
+    const systemKeyField = screen.getByTestId('managesystemconfigs-key-field');
+    const systemValueField = screen.getByTestId('managesystemconfigs-value-field');
+    const submitButton = screen.getByTestId('managesystemconfigs-submit-btn');
+
+    await act(async () => {
+      fireEvent.change(systemKeyField.querySelector('input'), { target: { value: 'SYSTEM_VERSION' } });
+      fireEvent.change(systemValueField.querySelector('input'), { target: { value: '0.1' } });
+      fireEvent.click(submitButton);
+    });
+
+    await waitFor(async () => {
+      expect(checkSystemConfigExists).toHaveBeenCalled();
+      expect(showToast).toHaveBeenCalledWith({
+        message: 'Same key already Exists',
+        type: 'error',
+      });
+    });
+  });
+});

package/src/_tests_/views/components/SystemConfig/ManageSystemConfig/UpdateManageSystemConfig.test.jsx.disable

@@ -0,0 +1,157 @@
+import React from 'react';
+import { act, cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import { customRender } from '@/common/tests/CustomWrapper';
+import { useNavigate, useParams } from 'react-router';
+import { checkSystemConfigExists, getSystemConfigsByKey, updateSystemConfig } from '@/common/services/SystemConfig';
+import { showToast } from '@/common/toaster/toaster';
+import ManageSystemConfig from '@/views/feature-components/system-config/ManageSystemConfigs';
+
+jest.mock('react-router', () => ({
+  ...jest.requireActual('react-router'),
+  useNavigate: jest.fn(),
+  useParams: jest.fn(),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key) => key,
+    i18n: { changeLanguage: () => new Promise(() => {}) },
+  }),
+}));
+
+jest.mock('../../../../../common/services/SystemConfig', () => ({
+  checkSystemConfigExists: jest.fn(),
+  getSystemConfigsByKey: jest.fn(),
+  updateSystemConfig: jest.fn(),
+}));
+
+jest.mock('../../../../../common/toaster/toaster', () => ({
+  showToast: jest.fn(),
+}));
+
+describe('ManageSystemConfig Component', () => {
+  let mockedNavigate;
+
+  const renderComponent = async (params = {}) => {
+    customRender(<ManageSystemConfig />, params);
+  };
+
+  beforeEach(async () => {
+    cleanup();
+    mockedNavigate = jest.fn();
+    useNavigate.mockImplementation(() => mockedNavigate);
+  });
+
+  describe('checking for existing system key', () => {
+    beforeEach(async () => {
+      useParams.mockReturnValue({ key: 'SYSTEM_VERSION' });
+      getSystemConfigsByKey.mockResolvedValue({
+        data: {
+          code: 'retrieve_system_configuration_by_key',
+          result: [
+            {
+              key: 'SYSTEM_VERSION',
+              isActive: true,
+              value: '0.1',
+            },
+          ],
+          parameters: null,
+          sequence: null,
+        },
+      });
+      await act(async () => {
+        await renderComponent({ url: '/ui/medplat/manage/systemconfigs/managesystemconfig/SYSTEM_VERSION' });
+      });
+    });
+    it('should render system config form with values', async () => {
+      const systemKeyField = screen.getByTestId('managesystemconfigs-key-field');
+      const systemValueField = screen.getByTestId('managesystemconfigs-value-field');
+      const updateButton = screen.getByTestId('managesystemconfigs-submit-btn');
+      const cancelButton = screen.getByTestId('managesystemconfigs-close-btn');
+
+      expect(systemKeyField.querySelector('label')).toHaveTextContent('Enter System Key');
+      expect(systemKeyField.querySelector('input')).toHaveValue('SYSTEM_VERSION');
+
+      expect(systemValueField).toBeInTheDocument();
+      expect(systemValueField.querySelector('label')).toHaveTextContent('Key Value');
+      expect(systemValueField.querySelector('input')).toHaveValue('0.1');
+
+      expect(updateButton).toBeInTheDocument();
+      expect(updateButton.querySelector('span')).toHaveTextContent('Update');
+
+      expect(cancelButton).toBeInTheDocument();
+      expect(cancelButton).toHaveTextContent('Close');
+    });
+
+    it('should navigate on close button click', async () => {
+      const closeButton = screen.getByTestId('managesystemconfigs-close-btn');
+      fireEvent.click(closeButton);
+
+      expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/systemconfigs');
+    });
+
+    it('should update the value and navigate ', async () => {
+      checkSystemConfigExists.mockResolvedValue({
+        data: {
+          code: 'check_if_system_configuration_exists',
+          result: [{ count: 1 }],
+          parameters: null,
+          sequence: null,
+        },
+      });
+
+      const updateButton = screen.getByTestId('managesystemconfigs-submit-btn');
+      const systemValueField = screen.getByTestId('managesystemconfigs-value-field');
+
+      await act(async () => {
+        fireEvent.change(systemValueField.querySelector('input'), { target: { value: '0.2' } });
+      });
+
+      expect(screen.getByTestId('managesystemconfigs-value-field').querySelector('input')).toHaveValue('0.2');
+
+      await act(async () => {
+        fireEvent.change(systemValueField.querySelector('input'), { target: { value: '0.2' } });
+      });
+
+      await act(async () => {
+        fireEvent.click(updateButton);
+      });
+      await waitFor(() => {
+        expect(checkSystemConfigExists).toHaveBeenCalled();
+        expect(updateSystemConfig).toHaveBeenCalled();
+        expect(showToast).toHaveBeenCalledWith({
+          message: `System Configuration Updated  successfully`,
+          type: 'success',
+        });
+        expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/systemconfigs');
+      });
+    });
+  });
+
+  describe('checking for non existing system key', () => {
+    let mockedNavigate;
+    beforeEach(async () => {
+      useParams.mockReturnValue({ key: 'unknown' });
+      getSystemConfigsByKey.mockResolvedValue({
+        data: {
+          code: 'retrieve_system_configuration_by_key',
+          result: [],
+          parameters: null,
+          sequence: null,
+        },
+      });
+      mockedNavigate = jest.fn();
+      useNavigate.mockImplementation(() => mockedNavigate);
+      await act(async () => {
+        await renderComponent({ url: '/ui/medplat/manage/systemconfigs/managesystemconfig/SYSTEM_VERSION' });
+      });
+    });
+    it('should render system config form with values', async () => {
+      await waitFor(async () => {
+        expect(getSystemConfigsByKey).toHaveBeenCalled();
+        expect(showToast).toHaveBeenCalledWith({ type: 'error', message: 'error loading initial data' });
+        expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/systemconfigs');
+      });
+    });
+  });
+});