@argusoft/medplat-app-shell 1.0.6 → 1.0.8

package/src/_tests_/views/components/LocationType/addlocationtype.test.jsx.disable

@@ -0,0 +1,276 @@
+import React from 'react';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import ManageLocationType from '@/views/feature-components/LocationType/ManageLocationType';
+import { retriveLocationType, createLocationType } from '@/common/services/LocationType';
+import { getRoleList } from '@/common/services/Roles';
+import { mockLocationData, mockRoleTypeData } from '@/_tests_/views/components/LocationType/MockLocationType';
+import { useNavigate } from 'react-router-dom';
+import MockTranslationProvider from '@/_tests_/__mocks__/MockTranslationProvider';
+
+jest.mock('../../../../common/services/LocationType', () => ({
+  retriveLocationType: jest.fn(),
+  createLocationType: jest.fn(),
+  getRoleList: jest.fn(),
+}));
+
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useNavigate: jest.fn(),
+}));
+
+jest.mock('../../../../common/services/Roles', () => ({
+  getRoleList: jest.fn(),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key) => key,
+    i18n: { changeLanguage: () => new Promise(() => {}) },
+  }),
+}));
+
+describe('manage location type component', () => {
+  beforeEach(() => {
+    retriveLocationType.mockResolvedValue(mockLocationData);
+    getRoleList.mockResolvedValue(mockRoleTypeData);
+  });
+
+  const renderComponent = async () => {
+    await act(async () => {
+      render(
+        <MockTranslationProvider>
+          <ManageLocationType />
+        </MockTranslationProvider>
+      );
+    });
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    cleanup();
+  });
+
+  describe('Checking the Element for creating Location Type', () => {
+    let mockedNavigate;
+    beforeEach(async () => {
+      mockedNavigate = jest.fn(); // Create a new mock function for each test
+      useNavigate.mockReturnValue(mockedNavigate); // Return the mocked function
+    });
+    beforeEach(async () => {
+      await renderComponent();
+    });
+    beforeAll(() => {
+      jest.setTimeout(20000);
+    });
+
+    it('should check submit button with all fields', async () => {
+      let options;
+
+      const [submitButton, typeInput, nameInput, levelInput] = await Promise.all([
+        waitFor(() => screen.getByTestId('managelocationtype-submit-button')),
+        waitFor(() => screen.getByTestId('managelocationtype-type-textfield').querySelector('input')),
+        waitFor(() => screen.getByTestId('managelocationtype-name-textfield').querySelector('input')),
+        waitFor(() => screen.getByTestId('managelocationtype-level-textfield').querySelector('input')),
+      ]);
+
+      expect(typeInput).toBeInTheDocument();
+      expect(nameInput).toBeInTheDocument();
+      expect(levelInput).toBeInTheDocument();
+      expect(submitButton).toBeInTheDocument();
+
+      fireEvent.change(typeInput, { target: { value: 'State' } });
+      fireEvent.change(nameInput, { target: { value: 'gandhinagar' } });
+      fireEvent.change(levelInput, { target: { value: '1' } });
+
+      await Promise.all([
+        waitFor(() => expect(typeInput.value).toBe('State')),
+        waitFor(() => expect(nameInput.value).toBe('gandhinagar')),
+        waitFor(() => expect(levelInput.value).toBe('1')),
+      ]);
+
+      const canAdd = screen.getAllByRole('combobox', { placeholder: /Select some options/i })[0];
+      fireEvent.mouseDown(canAdd);
+
+      const addListboxes = await screen.findAllByRole('listbox'); // Finds all listboxes
+      expect(addListboxes).toHaveLength(1); // Ensure only one listbox exists
+      const addList = addListboxes[0];
+      expect(addList).toBeInTheDocument();
+
+      options = screen.getAllByRole('option');
+      const addRole = options.find((option) => option.getAttribute('data-testid') === 'option-164');
+      act(() => {
+        addRole.click();
+      });
+
+      const ActionByInputOnAdd = screen.queryAllByRole('button')[0];
+      await waitFor(() => {
+        expect(screen.queryByRole('listbox')).toBeNull();
+        expect(ActionByInputOnAdd).toHaveTextContent('Accountant (Nutrition)');
+      });
+
+      const canDelete = screen.getAllByRole('combobox', { placeholder: /Select some options/i })[1];
+      expect(canDelete).toBeInTheDocument();
+      fireEvent.mouseDown(canDelete);
+
+      const deleteListboxes = await screen.findAllByRole('listbox'); // Finds all listboxes
+      expect(deleteListboxes).toHaveLength(1); // Ensure only one listbox exists
+      const deleteList = deleteListboxes[0];
+      expect(deleteList).toBeInTheDocument();
+
+      options = screen.getAllByRole('option');
+      const deleteRole = options.find((option) => option.getAttribute('data-testid') === 'option-164');
+      act(() => {
+        deleteRole.click();
+      });
+
+      const ActionByInputOnDelete = screen.queryAllByRole('button')[0];
+      await waitFor(() => {
+        expect(screen.queryByRole('listbox')).toBeNull();
+        expect(ActionByInputOnDelete).toHaveTextContent('Accountant (Nutrition)');
+      });
+
+      const canUpdate = screen.getAllByRole('combobox', { placeholder: /Select some options/i })[2];
+      expect(canUpdate).toBeInTheDocument();
+      fireEvent.mouseDown(canUpdate);
+
+      const updateListboxes = await screen.findAllByRole('listbox'); // Finds all listboxes
+      expect(updateListboxes).toHaveLength(1); // Ensure only one listbox exists
+      const updateList = updateListboxes[0];
+      expect(updateList).toBeInTheDocument();
+
+      options = screen.getAllByRole('option');
+      const updateRole = options.find((option) => option.getAttribute('data-testid') === 'option-164');
+      act(() => {
+        updateRole.click();
+      });
+
+      const ActionByInputOnUpdate = screen.queryAllByRole('button')[0];
+      await waitFor(() => {
+        expect(screen.queryByRole('listbox')).toBeNull();
+        expect(ActionByInputOnUpdate).toHaveTextContent('Accountant (Nutrition)');
+      });
+
+      // Submit the form
+      fireEvent.submit(submitButton);
+      await waitFor(() => {
+        expect(createLocationType).toHaveBeenCalledWith({
+          code: 'create_location_type',
+          parameters: {
+            type: 'State',
+            name: 'gandhinagar',
+            level: 1,
+            isSohEnable: true,
+            canAdd: '164',
+            canUpdate: '164',
+            canDelete: '164',
+          },
+        });
+      });
+    });
+
+    it('Checking elements of Manage location type : ', async () => {
+      const component = screen.getByTestId('managelocationtype-form');
+      expect(component).toBeInTheDocument();
+
+      const type = screen.getAllByText(/Type/);
+      expect(type).toHaveLength(2);
+
+      const name = screen.getByText(/Name/);
+      expect(name).toBeInTheDocument();
+
+      const level = screen.getByText(/Level/);
+      expect(level).toBeInTheDocument();
+
+      const canUpdate = screen.getByTestId('managelocationtype-canUpdate-select');
+      expect(canUpdate).toBeInTheDocument();
+
+      const canDelete = screen.getByTestId('managelocationtype-canDelete-select');
+      expect(canDelete).toBeInTheDocument();
+
+      const canAdd = screen.getByTestId('managelocationtype-canAdd-select');
+      expect(canAdd).toBeInTheDocument();
+
+      const submitButton = screen.getByTestId('managelocationtype-submit-button');
+      expect(submitButton).toBeInTheDocument();
+
+      const cancelButton = screen.getByTestId('managelocationtype-back-button');
+      expect(cancelButton).toBeInTheDocument();
+    });
+
+    it('should check blank submit button', async () => {
+      jest.setTimeout(100000);
+      let errorMessages;
+
+      const submitButton = screen.getByTestId('managelocationtype-submit-button');
+      const type = screen.getByTestId('managelocationtype-type-textfield');
+      const name = screen.getByTestId('managelocationtype-name-textfield');
+      const level = screen.getByTestId('managelocationtype-level-textfield');
+
+      expect(type).toBeInTheDocument();
+      expect(name).toBeInTheDocument();
+      expect(level).toBeInTheDocument();
+      expect(submitButton).toBeInTheDocument();
+
+      // submit empty form
+      const onSubmit = jest.fn();
+      fireEvent.click(submitButton);
+      await waitFor(() => {
+        expect(onSubmit).not.toHaveBeenCalled();
+        errorMessages = screen.getAllByTestId('custom-error-message');
+        errorMessages = errorMessages.map((msg) => msg.textContent.trim());
+
+        expect(errorMessages).toHaveLength(2);
+        expect(errorMessages).toContain('Please enter location type');
+        expect(errorMessages).toContain('Please enter location name');
+      });
+    });
+
+    it('should check submit button with only necessary field', async () => {
+      jest.setTimeout(100000);
+
+      const submitButton = screen.getByTestId('managelocationtype-submit-button');
+      const type = screen.getByTestId('managelocationtype-type-textfield').querySelector('input');
+      const name = screen.getByTestId('managelocationtype-name-textfield').querySelector('input');
+      const level = screen.getByTestId('managelocationtype-level-textfield').querySelector('input');
+
+      expect(type).toBeInTheDocument();
+      expect(name).toBeInTheDocument();
+      expect(level).toBeInTheDocument();
+      expect(submitButton).toBeInTheDocument();
+
+      fireEvent.change(type, { target: { value: 'State' } });
+      fireEvent.change(name, { target: { value: 'gandhinagar' } });
+      fireEvent.change(level, { target: { value: '1' } });
+
+      expect(type.value).toBe('State');
+      expect(name.value).toBe('gandhinagar');
+      expect(level.value).toBe('1');
+
+      fireEvent.submit(submitButton);
+      await waitFor(() => {
+        expect(createLocationType).toHaveBeenCalledWith({
+          code: 'create_location_type',
+          parameters: {
+            type: 'State',
+            name: 'gandhinagar',
+            level: 1,
+            isSohEnable: true,
+            canAdd: '',
+            canUpdate: '',
+            canDelete: '',
+          },
+        });
+      });
+    });
+
+    it('should route on cancel button click', async () => {
+      const cancelButton = screen.getByTestId('managelocationtype-back-button');
+      expect(cancelButton).toBeInTheDocument();
+
+      fireEvent.click(cancelButton);
+      await waitFor(() => {
+        expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/locationtype');
+      });
+    });
+  });
+});

package/src/_tests_/views/components/LocationType/editlocationtype.test.jsx.disable

@@ -0,0 +1,262 @@
+import React from 'react';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import ManageLocationType from '@/views/feature-components/LocationType/ManageLocationType';
+import { retriveLocationType, getLocationTypeById, updateLocationType } from '@/common/services/LocationType';
+import { getRoleList } from '@/common/services/Roles';
+import {
+  mockLocationData,
+  mockRetrieveData,
+  mockRoleTypeData,
+} from '@/_tests_/views/components/LocationType/MockLocationType';
+import { useNavigate } from 'react-router-dom'; // Ensure this is correct import
+import MockTranslationProvider from '@/_tests_/__mocks__/MockTranslationProvider';
+
+// Mocking the necessary services and modules
+jest.mock('../../../../common/services/LocationType', () => ({
+  retriveLocationType: jest.fn(),
+  createLocationType: jest.fn(),
+  getLocationTypeById: jest.fn(),
+  updateLocationType: jest.fn(),
+}));
+
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'), // To retain the original module functions
+  useNavigate: jest.fn(), // Correctly mock useNavigate
+  useParams: jest.fn().mockReturnValue({ id: '1' }), // Uncomment if you need useParams in tests
+}));
+
+jest.mock('../../../../common/services/Roles', () => ({
+  getRoleList: jest.fn(),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key) => key,
+    i18n: { changeLanguage: () => new Promise(() => {}) },
+  }),
+}));
+
+describe('manage location type component', () => {
+  const renderComponent = async () => {
+    await act(async () => {
+      render(
+        <MockTranslationProvider>
+          <ManageLocationType />
+        </MockTranslationProvider>
+      );
+    });
+  };
+
+  let mockedNavigate;
+  beforeEach(() => {
+    mockedNavigate = jest.fn(); // Create a new mock function for each test
+    useNavigate.mockReturnValue(mockedNavigate); // Return the mocked function
+
+    // Mocking resolved values for services
+    retriveLocationType.mockResolvedValue(mockLocationData);
+    getRoleList.mockResolvedValue(mockRoleTypeData);
+    getLocationTypeById.mockResolvedValue(mockRetrieveData);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    cleanup();
+  });
+
+  describe('Checking the Element for creating Location Type', () => {
+    beforeEach(async () => {
+      await renderComponent();
+    });
+
+    it('Checking elements of Manage location type', async () => {
+      // Check that the form elements are rendered correctly
+      const component = screen.getByTestId('managelocationtype-form');
+      expect(component).toBeInTheDocument();
+
+      const type = screen.getAllByText(/Type/);
+      expect(type).toHaveLength(2);
+
+      const name = screen.getByText(/Name/);
+      expect(name).toBeInTheDocument();
+
+      const level = screen.getByText(/Level/);
+      expect(level).toBeInTheDocument();
+
+      const submitButton = screen.getByTestId('managelocationtype-submit-button');
+      expect(submitButton).toHaveTextContent('Update');
+      expect(submitButton).toBeInTheDocument();
+
+      const cancelButton = screen.getByTestId('managelocationtype-back-button');
+      expect(cancelButton).toBeInTheDocument();
+    });
+
+    it('should populate the form with the location type data', async () => {
+      await waitFor(() => expect(getLocationTypeById).toHaveBeenCalled());
+      expect(getLocationTypeById).toHaveBeenCalledTimes(1);
+
+      // Wait for the form to be populated with the data
+      await waitFor(() => {
+        const submitButton = screen.getByTestId('managelocationtype-submit-button');
+        const type = screen.getByTestId('managelocationtype-type-textfield').querySelector('input');
+        const name = screen.getByTestId('managelocationtype-name-textfield').querySelector('input');
+        const level = screen.getByTestId('managelocationtype-level-textfield').querySelector('input');
+
+        expect(type).toHaveValue('S');
+        expect(name).toHaveValue('State');
+        expect(level).toHaveValue(1);
+        expect(submitButton).toBeInTheDocument();
+      });
+    });
+
+    it('should submit the form with the all values ', async () => {
+      let options;
+
+      await waitFor(() => expect(getLocationTypeById).toHaveBeenCalled());
+      expect(getLocationTypeById).toHaveBeenCalledTimes(1);
+
+      // Wait for the form to be populated with the data
+      const submitButton = screen.getByTestId('managelocationtype-submit-button');
+      const type = screen.getByTestId('managelocationtype-type-textfield').querySelector('input');
+      const name = screen.getByTestId('managelocationtype-name-textfield').querySelector('input');
+      const level = screen.getByTestId('managelocationtype-level-textfield').querySelector('input');
+
+      await waitFor(() => {
+        expect(type).toHaveValue('S');
+        expect(name).toHaveValue('State');
+        expect(level).toHaveValue(1);
+        expect(submitButton).toBeInTheDocument();
+      });
+
+      const canAdd = screen.getAllByRole('combobox', { placeholder: /Select some options/i })[0];
+      await act(async () => {
+        fireEvent.mouseDown(canAdd);
+      });
+
+      const addListboxes = await screen.findAllByRole('listbox'); // Finds all listboxes
+      expect(addListboxes).toHaveLength(1); // Ensure only one listbox exists
+      const addList = addListboxes[0];
+      expect(addList).toBeInTheDocument();
+
+      options = screen.getAllByRole('option');
+      const addRole = options.find((option) => option.getAttribute('data-testid') === 'option-164');
+      act(() => {
+        addRole.click();
+      });
+
+      const ActionByInputOnAdd = screen.queryAllByRole('button')[0];
+      await waitFor(() => {
+        expect(screen.queryByRole('listbox')).toBeNull();
+        expect(ActionByInputOnAdd).toHaveTextContent('Accountant (Nutrition)');
+      });
+
+      const canDelete = screen.getAllByRole('combobox', { placeholder: /Select some options/i })[1];
+      expect(canDelete).toBeInTheDocument();
+      await act(async () => {
+        fireEvent.mouseDown(canDelete);
+      });
+
+      const deleteListboxes = await screen.findAllByRole('listbox'); // Finds all listboxes
+      expect(deleteListboxes).toHaveLength(1); // Ensure only one listbox exists
+      const deleteList = deleteListboxes[0];
+      expect(deleteList).toBeInTheDocument();
+
+      options = screen.getAllByRole('option');
+      const deleteRole = options.find((option) => option.getAttribute('data-testid') === 'option-164');
+      act(() => {
+        deleteRole.click();
+      });
+
+      const ActionByInputOnDelete = screen.queryAllByRole('button')[0];
+      await waitFor(() => {
+        expect(screen.queryByRole('listbox')).toBeNull();
+        expect(ActionByInputOnDelete).toHaveTextContent('Accountant (Nutrition)');
+      });
+
+      const canUpdate = screen.getAllByRole('combobox', { placeholder: /Select some options/i })[2];
+      expect(canUpdate).toBeInTheDocument();
+      await act(async () => {
+        fireEvent.mouseDown(canUpdate);
+      });
+
+      const updateListboxes = await screen.findAllByRole('listbox'); // Finds all listboxes
+      expect(updateListboxes).toHaveLength(1); // Ensure only one listbox exists
+      const updateList = updateListboxes[0];
+      expect(updateList).toBeInTheDocument();
+
+      options = screen.getAllByRole('option');
+      const updateRole = options.find((option) => option.getAttribute('data-testid') === 'option-164');
+      act(() => {
+        updateRole.click();
+      });
+
+      const ActionByInputOnUpdate = screen.queryAllByRole('button')[0];
+      await waitFor(() => {
+        expect(screen.queryByRole('listbox')).toBeNull();
+        expect(ActionByInputOnUpdate).toHaveTextContent('Accountant (Nutrition)');
+      });
+
+      // Submit the form
+      await act(async () => {
+        fireEvent.click(submitButton);
+      });
+      await waitFor(() => {
+        expect(updateLocationType).toHaveBeenCalledWith({
+          code: 'update_location_type',
+          parameters: {
+            type: 'S',
+            name: 'State',
+            level: 1,
+            isSohEnable: true,
+            canAdd: '164',
+            canUpdate: '164',
+            canDelete: '164',
+            id: 1,
+          },
+        });
+      });
+    }, 100000);
+
+    it('should check blank submit button', async () => {
+      let errorMessages;
+
+      const submitButton = screen.getByTestId('managelocationtype-submit-button');
+      const type = screen.getByTestId('managelocationtype-type-textfield').querySelector('input');
+      const name = screen.getByTestId('managelocationtype-name-textfield').querySelector('input');
+      const level = screen.getByTestId('managelocationtype-level-textfield').querySelector('input');
+
+      fireEvent.change(type, { target: { value: '' } });
+      fireEvent.change(name, { target: { value: '' } });
+      fireEvent.change(level, { target: { value: '' } });
+
+      await Promise.all([
+        waitFor(() => expect(type.value).toBe('')),
+        waitFor(() => expect(name.value).toBe('')),
+        waitFor(() => expect(level.value).toBe('')),
+      ]);
+
+      // submit empty form
+      const onSubmit = jest.fn();
+      fireEvent.click(submitButton);
+      await waitFor(() => {
+        expect(onSubmit).not.toHaveBeenCalled();
+        errorMessages = screen.getAllByTestId('custom-error-message');
+        errorMessages = errorMessages.map((msg) => msg.textContent.trim());
+
+        expect(errorMessages).toHaveLength(3);
+        expect(errorMessages).toContain('Please enter location type');
+        expect(errorMessages).toContain('Please enter location name');
+        expect(errorMessages).toContain('Please enter location level');
+      });
+    });
+
+    it('should route on cancel button click', async () => {
+      const cancelButton = screen.getByTestId('managelocationtype-back-button');
+      expect(cancelButton).toBeInTheDocument();
+
+      fireEvent.click(cancelButton);
+      await waitFor(() => {
+        expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/locationtype');
+      });
+    });
+  });
+});

package/src/_tests_/views/components/LocationType/locationtype.test.jsx.disable

@@ -0,0 +1,148 @@
+import MockTranslationProvider from '@/_tests_/__mocks__/MockTranslationProvider';
+import { mockLocationData } from '@/_tests_/views/components/LocationType/MockLocationType.js';
+import { retriveLocationType, toggleLocationTypeStatus } from '@/common/services/LocationType.js';
+import LocationType from '@/views/feature-components/LocationType/LocationType.jsx';
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import React, { act } from 'react';
+import { useNavigate } from 'react-router-dom';
+
+jest.mock('../../../../common/services/LocationType.js', () => ({
+  retriveLocationType: jest.fn(),
+  toggleLocationTypeStatus: jest.fn(),
+}));
+
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useNavigate: jest.fn(),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key) => key,
+    i18n: { changeLanguage: () => new Promise(() => {}) },
+  }),
+}));
+
+describe('Location Type', () => {
+  const renderComponent = async () => {
+    await act(async () => {
+      render(
+        <MockTranslationProvider>
+          <LocationType />
+        </MockTranslationProvider>
+      );
+    });
+  };
+  let mockedNavigate;
+
+  beforeEach(async () => {
+    mockedNavigate = jest.fn();
+    useNavigate.mockImplementation(() => mockedNavigate);
+    // Set up mock implementations for service functions
+    retriveLocationType.mockResolvedValue(mockLocationData);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    cleanup();
+  });
+
+  describe('Checking the Element present in component', () => {
+    beforeEach(async () => {
+      await renderComponent();
+    });
+
+    it('should render the Location type Table and checking its length: ', async () => {
+      const table = screen.getByTestId('locationtype-customized-table');
+      expect(table).toBeInTheDocument();
+      const rows = within(table).getAllByRole('row');
+      expect(rows.length).toBeGreaterThan(1);
+      expect(rows.length).toBe(mockLocationData.data.length + 1);
+    });
+
+    it('should render the Location type Table ', async () => {
+      const AddButton = screen.getByTestId('locationtype-add-button');
+      expect(AddButton).toBeInTheDocument();
+    });
+
+    it('should render the Header of the table', async () => {
+      const title = screen.getByText(/Location Type/);
+      expect(title).toBeInTheDocument();
+    });
+
+    it('displays search input and allows searching', async () => {
+      const searchInput = screen.getByPlaceholderText(/Search Text/);
+      expect(searchInput).toBeInTheDocument();
+    });
+  });
+
+  describe('Checking the Function call', () => {
+    beforeEach(async () => {
+      await renderComponent();
+    });
+
+    it('should call the Search field to search the value in Table', async () => {
+      const searchInput = screen.getByPlaceholderText(/Search Text/);
+      expect(searchInput).toBeInTheDocument();
+
+      fireEvent.change(searchInput, { target: { value: 'state' } });
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await waitFor(() => {
+        const table = screen.getByTestId('locationtype-customized-table');
+        expect(table).toBeInTheDocument();
+
+        // Get the rows inside the table
+        const rows = within(table).getAllByRole('row');
+
+        expect(rows.length).toBe(2); // Ensure there is at least 1 data row
+        expect(rows[1].querySelectorAll('td')[0].textContent).toBe('State');
+        expect(rows[1].querySelectorAll('td')[1].textContent).toBe('S');
+      });
+    });
+
+    it('should call the Add button to add the new Location Type', async () => {
+      const addButton = screen.getByTestId('locationtype-add-button');
+      expect(addButton).toBeInTheDocument();
+      fireEvent.click(addButton);
+      await waitFor(() => {
+        expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/locationtype/managelocationtype');
+      });
+    });
+
+    it('should navigate to manage locationType when edit button is clicked', async () => {
+      const editButton = screen.getAllByTestId('EditIcon')[0];
+      expect(editButton).toBeInTheDocument();
+      fireEvent.click(editButton);
+      await waitFor(() => {
+        expect(mockedNavigate).toHaveBeenCalledWith('/ui/medplat/manage/locationtype/managelocationtype/1');
+      });
+    });
+
+    it('should set location type inactive when Menu button is clicked', async () => {
+      const deleteButton = screen.getAllByTestId('MenuIcon')[0];
+      expect(deleteButton).toBeInTheDocument();
+
+      act(() => {
+        fireEvent.click(deleteButton);
+      });
+
+      const menuItems = screen.getAllByRole('menuitem');
+      expect(menuItems.length).toBe(1);
+      act(() => {
+        fireEvent.click(menuItems[0]);
+      });
+      expect(screen.getByTestId('locationtype-confirmation-modal')).toBeInTheDocument();
+      const buttonToDelete = screen.getByTestId('locationtype-confirmation-modal-yes-button');
+      expect(buttonToDelete).toBeInTheDocument();
+      act(() => {
+        fireEvent.click(buttonToDelete);
+      });
+      expect(toggleLocationTypeStatus).toHaveBeenCalledWith({
+        code: 'toggle_location_type_status',
+        parameters: {
+          id: 1,
+        },
+      });
+    });
+  });
+});