@argusoft/medplat-app-shell 1.0.5 → 1.0.7

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

@@ -0,0 +1,165 @@
+import MockTranslationProvider from '@/_tests_/__mocks__/MockTranslationProvider';
+import { mockSystemConfig } from '@/_tests_/views/components/SystemConfig/MockSystemConfig';
+import { getSystemConfigs, updateSystemConfig } from '@/common/services/SystemConfig';
+import SystemConfig from '@/views/feature-components/system-config/SystemConfig';
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import React, { act } from 'react';
+import { useNavigate } from 'react-router-dom';
+
+// Mock the necessary imports
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key) => key,
+    i18n: { changeLanguage: () => new Promise(() => {}) },
+  }),
+}));
+
+jest.mock('../../../../common/services/SystemConfig', () => ({
+  getSystemConfigs: jest.fn(),
+  updateSystemConfig: jest.fn(),
+}));
+
+jest.mock('../../../../utils/feature', () => ({
+  getAssignedFeatures: jest.fn().mockResolvedValue({
+    data: '{"canAdd": true}',
+  }),
+}));
+
+jest.mock('../../../../common/toaster/toaster', () => ({
+  showToast: jest.fn(),
+}));
+
+jest.mock('react-router', () => ({
+  useNavigate: jest.fn(),
+}));
+
+jest.mock('../../../../assets/img/medplat-highres.png', () => 'test-image-path');
+
+describe('SystemConfig Component', () => {
+  const renderComponent = async () => {
+    await act(async () => {
+      render(
+        <MockTranslationProvider>
+          <SystemConfig />
+        </MockTranslationProvider>
+      );
+    });
+  };
+  let mockedNavigate;
+
+  beforeEach(async () => {
+    mockedNavigate = jest.fn();
+    useNavigate.mockImplementation(() => mockedNavigate);
+    getSystemConfigs.mockResolvedValue(mockSystemConfig);
+    await renderComponent();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    cleanup();
+  });
+
+  it('should render the system config table and match row length', async () => {
+    const table = screen.getByTestId('systemconfig-customizedtable-main');
+    expect(table).toBeInTheDocument();
+
+    await waitFor(() => {
+      const rows = within(table).getAllByRole('row');
+      expect(rows.length).toBeGreaterThan(1);
+      expect(rows.length).toBe(mockSystemConfig.data.result.length + 1);
+    });
+  });
+
+  it('should render the add button on screen ', async () => {
+    const AddButton = screen.getByTestId('systemconfig-button-add');
+    expect(AddButton).toBeInTheDocument();
+  });
+
+  it('should call the Search field to search the value in Table', async () => {
+    const searchInput = screen.getByPlaceholderText(/Search Text/);
+    expect(searchInput).toBeInTheDocument();
+
+    await act(async () => {
+      fireEvent.change(searchInput, { target: { value: 'system_v' } });
+    });
+
+    const table = screen.getByTestId('systemconfig-customizedtable-main');
+    const rows = within(table).getAllByRole('row');
+    await waitFor(() => {
+      expect(table).toBeInTheDocument();
+
+      expect(rows.length).toBe(2);
+      expect(rows[1]).toHaveTextContent('SYSTEM_VERSION');
+    });
+  });
+
+  it('should call the Add button to add the new Location Type', async () => {
+    const addButton = screen.getByTestId('systemconfig-button-add');
+    expect(addButton).toBeInTheDocument();
+    fireEvent.click(addButton);
+    await waitFor(() => {
+      expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/systemconfigs/managesystemconfig');
+    });
+  });
+  it('should render modal on clicking on menuicon ', async () => {
+    const table = screen.getByTestId('systemconfig-customizedtable-main');
+    const rows = within(table).getAllByRole('row');
+
+    const menuIcon = within(rows[1]).getByTestId('MenuIcon');
+    await act(async () => {
+      fireEvent.click(menuIcon);
+    });
+
+    const menuDropdown = screen.getByRole('menuitem');
+    expect(menuDropdown).toHaveTextContent('Mark as Inactive');
+
+    await act(async () => {
+      fireEvent.click(menuDropdown);
+    });
+
+    const modal = screen.getByTestId('systemconfig-modal-confirmation');
+
+    const modalTitle = within(modal).getByTestId('systemconfig-modal-confirmation-title');
+    const modalClose = within(modal).getByTestId('systemconfig-modal-confirmation-close-button');
+    const modalDescription = within(modal).getByTestId('systemconfig-modal-confirmation-description');
+    const modalNoButton = within(modal).getByTestId('systemconfig-modal-confirmation-no-button');
+    const modalYesButton = within(modal).getByTestId('systemconfig-modal-confirmation-yes-button');
+
+    expect(modalTitle).toHaveTextContent('CONFIRMACTION');
+    expect(modalClose).toBeInTheDocument();
+    expect(modalDescription).toHaveTextContent(
+      'Are you sure you want to change the state of this System configuration ?'
+    );
+    expect(modalNoButton).toHaveTextContent('No');
+    expect(modalYesButton).toHaveTextContent('Yes');
+
+    await act(async () => {
+      fireEvent.click(modalYesButton);
+    });
+    await waitFor(() => {
+      expect(updateSystemConfig).toHaveBeenCalled();
+    });
+    await act(async () => {
+      fireEvent.click(menuIcon);
+    });
+  }, 100000);
+  it('should navigate to the on click on the edit button', async () => {
+    const searchInput = screen.getByPlaceholderText(/Search Text/);
+    expect(searchInput).toBeInTheDocument();
+
+    await act(async () => {
+      fireEvent.change(searchInput, { target: { value: 'system_v' } });
+    });
+
+    const table = screen.getByTestId('systemconfig-customizedtable-main');
+    const rows = within(table).getAllByRole('row');
+
+    const editIcon = within(rows[1]).getByTestId('EditIcon');
+    await act(async () => {
+      fireEvent.click(editIcon);
+    });
+    await waitFor(() => {
+      expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/systemconfigs/managesystemconfig/SYSTEM_VERSION');
+    });
+  });
+});

package/src/_tests_/views/components/login/Login.test.jsx

@@ -0,0 +1,276 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor, cleanup } from '@testing-library/react';
+import { useDispatch, useSelector } from 'react-redux';
+import { useNavigate } from 'react-router-dom';
+import Login from '@/views/feature-components/login/Login.jsx'; // Adjust the path as necessary
+import {
+  loginService,
+  getLoggedInUser,
+  getFeatures,
+  getApkInfo,
+  getSystemNotice,
+} from '@/common/services/AuthenticateService';
+import { showToast } from '@/common/toaster/toaster';
+import {
+  loginServiceResponse,
+  mockGetFeatureResponse,
+  mockLoggedInUserResponse,
+  mockLoggeinUser,
+} from '@/_tests_/views/components/login/ServiceResponse';
+
+// jest.mock('../../../../assets/img/medplat-highres.png', () => 'test-image-path');
+
+// Mock services and utilities
+jest.mock('@/common/services/AuthenticateService', () => ({
+  getKeyAndIV: jest.fn(),
+  loginService: jest.fn(),
+  getLoggedInUser: jest.fn(),
+  getFeatures: jest.fn(),
+  getApkInfo: jest.fn(),
+  getSystemNotice: jest.fn(),
+}));
+jest.mock('@/common/toaster/toaster', () => ({
+  showToast: jest.fn(),
+}));
+jest.mock('react-redux', () => ({
+  useSelector: jest.fn(),
+  useDispatch: jest.fn(),
+}));
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useNavigate: jest.fn(),
+}));
+jest.mock('react-redux', () => ({
+  useSelector: jest.fn(),
+  useDispatch: jest.fn(),
+}));
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useNavigate: jest.fn(),
+}));
+
+describe('Login Component', () => {
+  const renderComponent = async () => render(<Login />);
+
+  beforeEach(async () => {
+    const mockNavigate = jest.fn();
+    const mockDispatch = jest.fn();
+    useSelector.mockImplementation((callback) =>
+      callback({
+        Authenticate: { user: mockLoggeinUser },
+      })
+    );
+    useDispatch.mockReturnValue(mockDispatch);
+    useNavigate.mockImplementation(() => mockNavigate);
+
+    getApkInfo.mockResolvedValue({
+      data: '',
+      status: 200,
+      statusText: '',
+      headers: {
+        'cache-control': 'no-cache, no-store, must-revalidate',
+        'content-length': '0',
+        expires: 'Wed, 31 Dec 1969 23:59:59 GMT',
+        pragma: 'no-cache',
+      },
+      config: {
+        transitional: {
+          silentJSONParsing: true,
+          forcedJSONParsing: true,
+          clarifyTimeoutError: false,
+        },
+        adapter: ['xhr', 'http', 'fetch'],
+        transformRequest: [null],
+        transformResponse: [null],
+        timeout: 0,
+        xsrfCookieName: 'XSRF-TOKEN',
+        xsrfHeaderName: 'X-XSRF-TOKEN',
+        maxContentLength: -1,
+        maxBodyLength: -1,
+        env: {},
+        headers: {
+          Accept: 'application/json, text/plain, */*',
+        },
+        baseURL: 'http://localhost:8181/api',
+        method: 'get',
+        url: '/mobile/systemNotice',
+      },
+      request: {},
+    });
+    getSystemNotice.mockResolvedValue({
+      data: '',
+      status: 200,
+      statusText: '',
+      headers: {
+        'cache-control': 'no-cache, no-store, must-revalidate',
+        'content-length': '0',
+        expires: 'Wed, 31 Dec 1969 23:59:59 GMT',
+        pragma: 'no-cache',
+      },
+      config: {
+        transitional: {
+          silentJSONParsing: true,
+          forcedJSONParsing: true,
+          clarifyTimeoutError: false,
+        },
+        adapter: ['xhr', 'http', 'fetch'],
+        transformRequest: [null],
+        transformResponse: [null],
+        timeout: 0,
+        xsrfCookieName: 'XSRF-TOKEN',
+        xsrfHeaderName: 'X-XSRF-TOKEN',
+        maxContentLength: -1,
+        maxBodyLength: -1,
+        env: {},
+        headers: {
+          Accept: 'application/json, text/plain, */*',
+        },
+        method: 'get',
+        url: 'http://localhost:8181/api/mobile/systemNotice',
+      },
+      request: {},
+    });
+
+    await renderComponent();
+  });
+
+  afterEach(() => {
+    cleanup();
+    jest.clearAllMocks(); // Clears any mocks/spies created with jest.fn or jest.spyOn
+  });
+
+  it('renders the Login component', async () => {
+    expect(screen.getByTestId('Login Form')).toBeInTheDocument();
+    expect(screen.getByTestId('username')).toBeInTheDocument();
+    expect(screen.getByRole('textbox', { id: 'username' })).toBeInTheDocument();
+    expect(screen.getByRole('textbox', { id: 'password' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Login' })).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'Forgot password?' })).toBeInTheDocument();
+  });
+
+  it('shows validation errors', async () => {
+    fireEvent.click(screen.getByRole('button', { name: 'Login' }));
+
+    let errorMessages;
+    await waitFor(() => {
+      errorMessages = screen.getAllByTestId('custom-error-message');
+      errorMessages = errorMessages.map((msg) => msg.textContent.trim());
+      expect(errorMessages).toHaveLength(2);
+
+      expect(errorMessages).toContain('Username is required');
+      expect(errorMessages).toContain('Password is required');
+    });
+
+    const usernameInput = screen.getByPlaceholderText(/username/i);
+    fireEvent.change(usernameInput, { target: { value: 'testuser' } });
+    await waitFor(() => {
+      expect(usernameInput.value).toBe('testuser');
+      errorMessages = screen.getAllByTestId('custom-error-message');
+      errorMessages = errorMessages.map((msg) => msg.textContent.trim());
+      expect(errorMessages).toHaveLength(1);
+      expect(errorMessages).not.toContain('Username is required');
+      expect(errorMessages).toContain('Password is required');
+    });
+
+    const passwordInput = screen.getByPlaceholderText(/password/i);
+    fireEvent.change(passwordInput, { target: { value: '123456789' } });
+    await waitFor(() => {
+      expect(passwordInput.value).toBe('123456789');
+      expect(screen.queryByTestId('custom-error-message')).not.toBeInTheDocument();
+    });
+  });
+
+  it('calls the loginService and handles successful login', async () => {
+    loginService.mockResolvedValue(loginServiceResponse);
+    getLoggedInUser.mockResolvedValue(mockLoggedInUserResponse);
+    getFeatures.mockResolvedValue(mockGetFeatureResponse);
+
+    const usernameInput = screen.getByPlaceholderText(/username/i);
+    const passwordInput = screen.getByPlaceholderText(/password/i);
+
+    fireEvent.input(usernameInput, {
+      target: { value: 'ppratham' },
+    });
+    fireEvent.input(passwordInput, {
+      target: { value: '12345678' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: /login/i }));
+
+    await waitFor(() => {
+      expect(loginService).toHaveBeenCalledWith('ppratham', '12345678');
+      expect(getLoggedInUser).toHaveBeenCalled();
+      expect(getFeatures).toHaveBeenCalled();
+      // expect(mockedUseNavigate).toHaveBeenCalled()
+    });
+  });
+
+  it('shows a toast message on failed login', async () => {
+    loginService.mockImplementation(
+      () =>
+        new Promise((resolve, reject) =>
+          setTimeout(
+            () =>
+              reject({
+                response: {
+                  data: {
+                    error: 'invalid_grant',
+                    error_description: 'Bad Credentials',
+                  },
+                },
+              }),
+            100
+          )
+        )
+    );
+
+    const usernameInput = screen.getByPlaceholderText(/username/i); // Adjust if necessary
+    const passwordInput = screen.getByPlaceholderText(/password/i);
+
+    // Trigger a change event on the username and password inputs
+    fireEvent.change(usernameInput, { target: { value: 'testuser' } });
+    fireEvent.change(passwordInput, { target: { value: '123456789' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Login' }));
+
+    await waitFor(() => {
+      expect(showToast).toHaveBeenCalledWith({
+        message: 'Bad Credentials',
+        type: 'error',
+      });
+    });
+  });
+
+  it('shows a toast message and lock account on 3rd failed login', async () => {
+    loginService.mockImplementation(
+      () =>
+        new Promise((resolve, reject) =>
+          setTimeout(
+            () =>
+              reject({
+                response: {
+                  data: {
+                    error: 'invalid_grant',
+                    error_description: 'Your account is locked for 15 minutes. Please try again later',
+                  },
+                },
+              }),
+            100
+          )
+        )
+    );
+
+    const usernameInput = screen.getByPlaceholderText(/username/i); // Adjust if necessary
+    const passwordInput = screen.getByPlaceholderText(/password/i);
+
+    // Trigger a change event on the username and password inputs
+    fireEvent.change(usernameInput, { target: { value: 'testuser' } });
+    fireEvent.change(passwordInput, { target: { value: '123456789' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Login' }));
+
+    await waitFor(() => {
+      expect(showToast).toHaveBeenCalledWith({
+        message: 'Your account is locked for 15 minutes. Please try again later',
+        type: 'error',
+      });
+    });
+  });
+});