@kenyaemr/esm-admin-app 5.4.5-pre.795 → 5.4.5-pre.798

package/src/components/provider-banner/provider-banner.test.tsx

@@ -0,0 +1,109 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom/vitest';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { SWRConfig } from 'swr';
+import dayjs from 'dayjs';
+import { openmrsFetch, useSession } from '@openmrs/esm-framework';
+
+import ProviderBannerTag from './provider-banner.component';
+import { type Attribute } from './provider-banner.resource';
+
+const mockOpenmrsFetch = vi.mocked(openmrsFetch);
+const mockUseSession = vi.mocked(useSession);
+
+function mockProviderResponse(attributes: Array<Attribute>, display = 'Super User') {
+  mockOpenmrsFetch.mockResolvedValue({
+    data: { person: { display }, attributes },
+  } as unknown as Awaited<ReturnType<typeof openmrsFetch>>);
+}
+
+function licenseExpiry(value: string): Attribute {
+  return { attributeType: { display: 'License Expiry Date' }, value };
+}
+
+const uniqueIdentifier: Attribute = { attributeType: { display: 'Provider unique identifier' }, value: 'HWI-001' };
+
+function renderBanner() {
+  return render(
+    <SWRConfig value={{ provider: () => new Map(), dedupingInterval: 0 }}>
+      <ProviderBannerTag />
+    </SWRConfig>,
+  );
+}
+
+describe('ProviderBannerTag', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseSession.mockReturnValue({
+      currentProvider: { uuid: 'provider-1', identifier: 'HWI-001' },
+    } as unknown as ReturnType<typeof useSession>);
+  });
+
+  it('shows an inline loading indicator while fetching', () => {
+    mockOpenmrsFetch.mockReturnValue(new Promise(() => {}) as ReturnType<typeof openmrsFetch>);
+    renderBanner();
+    expect(screen.getByText('loading...')).toBeInTheDocument();
+  });
+
+  it('fetches the provider attributes for the session provider', async () => {
+    mockProviderResponse([uniqueIdentifier]);
+    renderBanner();
+    await screen.findByText('SUPER USER');
+    expect(mockOpenmrsFetch).toHaveBeenCalledWith(
+      '/ws/rest/v1/provider/provider-1?v=custom:(person:(display),attributes:(attributeType:(display),value))',
+    );
+  });
+
+  it('renders the identifier, upper-cased name, and an Unlicensed tag when there is no license expiry', async () => {
+    mockProviderResponse([uniqueIdentifier]);
+    renderBanner();
+
+    expect(await screen.findByText('SUPER USER')).toBeInTheDocument();
+    expect(screen.getByText('HWI-001')).toBeInTheDocument();
+    expect(screen.getByText('Unlicensed')).toBeInTheDocument();
+  });
+
+  it('falls back to NONE when the provider has no identifier or name', async () => {
+    mockProviderResponse([], '');
+    renderBanner();
+    expect(await screen.findAllByText('NONE')).toHaveLength(2);
+  });
+
+  it('shows a valid license tag with the expiry date when the license lasts beyond 90 days', async () => {
+    const expiry = dayjs().add(120, 'day');
+    mockProviderResponse([uniqueIdentifier, licenseExpiry(expiry.toISOString())]);
+    renderBanner();
+
+    expect(await screen.findByText('Valid License')).toBeInTheDocument();
+    expect(screen.getByText(expiry.format('YYYY-MM-DD'))).toBeInTheDocument();
+  });
+
+  it('shows an expires-in-3-months tag when the license expires within 90 days', async () => {
+    mockProviderResponse([licenseExpiry(dayjs().add(60, 'day').toISOString())]);
+    renderBanner();
+    expect(await screen.findByText('Expires in 3 months')).toBeInTheDocument();
+  });
+
+  it('shows an expires-soon tag when the license expires within 30 days', async () => {
+    mockProviderResponse([licenseExpiry(dayjs().add(20, 'day').toISOString())]);
+    renderBanner();
+    expect(await screen.findByText('Expires Soon')).toBeInTheDocument();
+  });
+
+  it('shows an expired tag when the license expiry is in the past', async () => {
+    mockProviderResponse([licenseExpiry(dayjs().subtract(10, 'day').toISOString())]);
+    renderBanner();
+    expect(await screen.findByText('License Expired')).toBeInTheDocument();
+  });
+
+  it('renders the banner-style error tag with the error message on hover when the request fails', async () => {
+    mockOpenmrsFetch.mockRejectedValue(new Error('Server unavailable'));
+    renderBanner();
+
+    expect(await screen.findByText('Error loading provider information')).toBeInTheDocument();
+    expect(screen.getByText('Provider:')).toBeInTheDocument();
+    expect(screen.getByTitle('Server unavailable')).toBeInTheDocument();
+    expect(screen.queryByText('Identifier:')).not.toBeInTheDocument();
+  });
+});

package/src/components/users/manage-users/manage-user-role-scope/user-role-scope-list/user-role-scope-list.component.test.tsx

@@ -0,0 +1,154 @@
+import React from 'react';
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { restBaseUrl, showModal, showSnackbar } from '@openmrs/esm-framework';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { deleteUserRoleScopes, handleMutation, useUserRoleScopes } from '../../../../../user-management.resources';
+import { type User, type UserRoleScope } from '../../../../../types';
+import StockUserRoleScopesList from './user-role-scope-list.component';
+
+vi.mock('../../../../../user-management.resources', () => ({
+  deleteUserRoleScopes: vi.fn(),
+  handleMutation: vi.fn(),
+  useUserRoleScopes: vi.fn(),
+}));
+
+const user = {
+  uuid: 'user-1',
+  username: 'alice',
+  roles: [],
+} as User;
+
+const roleScope: UserRoleScope = {
+  uuid: 'scope-1',
+  userUuid: 'user-1',
+  role: 'Inventory Clerk',
+  permanent: true,
+  enabled: true,
+  locations: [
+    { locationUuid: 'location-1', locationName: 'Main Store', enableDescendants: true },
+    { locationUuid: 'location-2', locationName: 'Pharmacy', enableDescendants: false },
+  ],
+  operationTypes: [
+    { operationTypeUuid: 'operation-1', operationTypeName: 'Stock Issue' },
+    { operationTypeUuid: 'operation-2', operationTypeName: 'Stock Receipt' },
+  ],
+};
+
+const mockUseUserRoleScopes = vi.mocked(useUserRoleScopes);
+const mockDeleteUserRoleScopes = vi.mocked(deleteUserRoleScopes);
+const mockHandleMutation = vi.mocked(handleMutation);
+const mockShowModal = vi.mocked(showModal);
+const mockShowSnackbar = vi.mocked(showSnackbar);
+
+describe('StockUserRoleScopesList', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseUserRoleScopes.mockReturnValue({
+      items: { results: [roleScope], totalCount: 1 },
+      loadingRoleScope: false,
+      userRoleScopeError: undefined,
+      isValidating: false,
+    });
+    mockShowModal.mockReturnValue(vi.fn());
+  });
+
+  it('shows a skeleton while role scopes are loading', () => {
+    mockUseUserRoleScopes.mockReturnValue({
+      items: undefined,
+      loadingRoleScope: true,
+      userRoleScopeError: undefined,
+      isValidating: false,
+    });
+
+    const { container } = render(<StockUserRoleScopesList user={user} />);
+    expect(container.querySelector('.cds--skeleton')).toBeInTheDocument();
+  });
+
+  it('renders only the selected user role scopes', () => {
+    mockUseUserRoleScopes.mockReturnValue({
+      items: {
+        results: [roleScope, { ...roleScope, uuid: 'scope-2', userUuid: 'another-user', role: 'Hidden Role' }],
+        totalCount: 2,
+      },
+      loadingRoleScope: false,
+      userRoleScopeError: undefined,
+      isValidating: true,
+    });
+
+    render(<StockUserRoleScopesList user={user} />);
+
+    expect(screen.getByRole('table', { name: 'user role scope table' })).toBeVisible();
+    expect(screen.getByText('Inventory Clerk')).toBeVisible();
+    expect(screen.getByText('Main Store')).toBeVisible();
+    expect(screen.getByText('Pharmacy')).toBeVisible();
+    expect(screen.getByText('Stock Issue, Stock Receipt')).toBeVisible();
+    expect(screen.getAllByText('Yes')).toHaveLength(2);
+    expect(screen.queryByText('Hidden Role')).not.toBeInTheDocument();
+    expect(screen.getByText('Refreshing user scopes...')).toBeVisible();
+  });
+
+  it('shows an empty state when the user has no role scopes', () => {
+    mockUseUserRoleScopes.mockReturnValue({
+      items: { results: [], totalCount: 0 },
+      loadingRoleScope: false,
+      userRoleScopeError: undefined,
+      isValidating: false,
+    });
+
+    render(<StockUserRoleScopesList user={user} />);
+    expect(screen.getByRole('heading', { name: 'User Role Scope' })).toBeVisible();
+    expect(screen.queryByText('Inventory Clerk')).not.toBeInTheDocument();
+  });
+
+  it('passes the selected scope to the edit callback', async () => {
+    const userEventInstance = userEvent.setup();
+    const onEditUserRoleScope = vi.fn();
+    render(<StockUserRoleScopesList user={user} onEditUserRoleScope={onEditUserRoleScope} />);
+
+    await userEventInstance.click(screen.getByRole('button', { name: 'Options' }));
+    await userEventInstance.click(await screen.findByText('Edit'));
+
+    expect(onEditUserRoleScope).toHaveBeenCalledWith(roleScope);
+  });
+
+  it('deletes a role scope and refreshes the list after confirmation', async () => {
+    const userEventInstance = userEvent.setup();
+    mockDeleteUserRoleScopes.mockResolvedValue({} as Awaited<ReturnType<typeof deleteUserRoleScopes>>);
+    render(<StockUserRoleScopesList user={user} />);
+
+    await userEventInstance.click(screen.getByRole('button', { name: 'Options' }));
+    await userEventInstance.click(await screen.findByText('Delete'));
+
+    expect(mockShowModal).toHaveBeenCalledWith(
+      'delete-stock-user-scope-modal',
+      expect.objectContaining({ uuid: 'scope-1', onConfirmation: expect.any(Function) }),
+    );
+    const [, modalProps] = mockShowModal.mock.calls[0] as [string, { onConfirmation: () => void }];
+
+    await act(async () => modalProps.onConfirmation());
+
+    expect(mockDeleteUserRoleScopes).toHaveBeenCalledWith(['scope-1']);
+    expect(mockHandleMutation).toHaveBeenCalledWith(`${restBaseUrl}/stockmanagement/userrolescope`);
+    expect(mockShowSnackbar).toHaveBeenCalledWith(
+      expect.objectContaining({ kind: 'success', subtitle: 'Stock User Scope Deleted Successfully' }),
+    );
+  });
+
+  it('shows an error notification when deletion fails', async () => {
+    const userEventInstance = userEvent.setup();
+    mockDeleteUserRoleScopes.mockRejectedValue(new Error('Delete failed'));
+    render(<StockUserRoleScopesList user={user} />);
+
+    await userEventInstance.click(screen.getByRole('button', { name: 'Options' }));
+    await userEventInstance.click(await screen.findByText('Delete'));
+    const [, modalProps] = mockShowModal.mock.calls[0] as [string, { onConfirmation: () => void }];
+
+    await act(async () => modalProps.onConfirmation());
+
+    expect(mockHandleMutation).not.toHaveBeenCalled();
+    expect(mockShowSnackbar).toHaveBeenCalledWith(
+      expect.objectContaining({ kind: 'error', subtitle: 'Delete failed' }),
+    );
+  });
+});

package/src/components/users/manage-users/manage-user-role-scope/user-role-scope-workspace/user-role-scope-fields.component.test.tsx

@@ -0,0 +1,161 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { FormProvider, useForm } from 'react-hook-form';
+import { describe, expect, it, vi } from 'vitest';
+import { type Role, type StockOperationType, type UserRoleScope } from '../../../../../types';
+import UserRoleScopeFormFields from './user-role-scope-fields.component';
+
+vi.mock('@carbon/react', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@carbon/react')>();
+  return {
+    ...original,
+    DatePicker: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+    DatePickerInput: ({ id, labelText }: { id: string; labelText: React.ReactNode }) => (
+      <label htmlFor={id}>
+        {labelText}
+        <input id={id} />
+      </label>
+    ),
+  };
+});
+
+const roles: Array<Role> = [
+  { uuid: 'role-1', display: 'Inventory Clerk' },
+  { uuid: 'role-2', display: 'Inventory Manager' },
+];
+
+const stockOperations = [
+  { uuid: 'operation-1', name: 'Stock Issue' },
+  { uuid: 'operation-2', name: 'Stock Receipt' },
+] as Array<StockOperationType>;
+
+const stockLocations = [
+  { id: 'location-1', name: 'Main Store' },
+  { id: 'location-2', name: 'Pharmacy' },
+] as Array<fhir.Location>;
+
+const emptyScope = null as UserRoleScope;
+
+function TestForm({
+  defaultValues = {
+    forms: [
+      {
+        role: '',
+        enabled: false,
+        permanent: false,
+        dateRange: {},
+        operationTypes: [],
+        locations: [],
+      },
+    ],
+  },
+  loadingStock = false,
+  initialScope = emptyScope,
+  removeForm = vi.fn(),
+}: {
+  defaultValues?: Record<string, any>;
+  loadingStock?: boolean;
+  initialScope?: UserRoleScope;
+  removeForm?: (index: number) => void;
+}) {
+  const methods = useForm({ defaultValues });
+  return (
+    <FormProvider {...methods}>
+      <UserRoleScopeFormFields
+        field={{}}
+        index={0}
+        control={methods.control}
+        removeForm={removeForm}
+        filteredInventoryRoles={roles}
+        hasInventoryRole
+        stockOperations={stockOperations}
+        loadingStock={loadingStock}
+        stockLocations={stockLocations}
+        roleScopeformMethods={methods}
+        userRoleScopeInitialValues={initialScope}
+      />
+      <output data-testid="values">{JSON.stringify(methods.watch())}</output>
+    </FormProvider>
+  );
+}
+
+describe('UserRoleScopeFormFields', () => {
+  it('renders the role, access, operation, and location controls', () => {
+    render(<TestForm />);
+
+    expect(screen.getByText('Stock Role')).toBeVisible();
+    expect(screen.getByText('Stock Role Access')).toBeVisible();
+    expect(screen.getByLabelText('Enable?')).not.toBeChecked();
+    expect(screen.getByLabelText('Stock Issue')).not.toBeChecked();
+    expect(screen.getByLabelText('Stock Receipt')).not.toBeChecked();
+    expect(screen.getByLabelText('Main Store')).not.toBeChecked();
+    expect(screen.getByLabelText('Pharmacy')).not.toBeChecked();
+  });
+
+  it('shows duration controls when enabled and clears dates when permanent is selected', async () => {
+    const user = userEvent.setup();
+    render(
+      <TestForm
+        defaultValues={{
+          forms: [
+            {
+              enabled: false,
+              permanent: false,
+              dateRange: { activeFrom: new Date('2026-08-01'), activeTo: new Date('2026-08-02') },
+              operationTypes: [],
+              locations: [],
+            },
+          ],
+        }}
+      />,
+    );
+
+    await user.click(screen.getByLabelText('Enable?'));
+    expect(screen.getByLabelText('Permanent?')).toBeVisible();
+    expect(screen.getByText('Active From')).toBeVisible();
+    expect(screen.getByText('Active To')).toBeVisible();
+
+    await user.click(screen.getByLabelText('Permanent?'));
+    expect(screen.queryByText('Active From')).not.toBeInTheDocument();
+    expect(screen.getByTestId('values')).toHaveTextContent('"dateRange":{}');
+  });
+
+  it('adds and removes stock operations and locations', async () => {
+    const user = userEvent.setup();
+    render(<TestForm />);
+
+    await user.click(screen.getByLabelText('Stock Issue'));
+    await user.click(screen.getByLabelText('Main Store'));
+    expect(screen.getByTestId('values')).toHaveTextContent(
+      '"operationTypes":[{"operationTypeUuid":"operation-1","operationTypeName":"Stock Issue"}]',
+    );
+    expect(screen.getByTestId('values')).toHaveTextContent(
+      '"locations":[{"locationName":"Main Store","locationUuid":"location-1"}]',
+    );
+
+    await user.click(screen.getByLabelText('Stock Issue'));
+    await user.click(screen.getByLabelText('Main Store'));
+    expect(screen.getByTestId('values')).toHaveTextContent('"operationTypes":[]');
+    expect(screen.getByTestId('values')).toHaveTextContent('"locations":[]');
+  });
+
+  it('shows loading indicators while stock data is loading', () => {
+    render(<TestForm loadingStock />);
+    expect(screen.getAllByText('Loading data...')).toHaveLength(2);
+    expect(screen.queryByLabelText('Stock Issue')).not.toBeInTheDocument();
+    expect(screen.queryByLabelText('Main Store')).not.toBeInTheDocument();
+  });
+
+  it('removes a new form but does not offer removal while editing', async () => {
+    const user = userEvent.setup();
+    const removeForm = vi.fn();
+    const { rerender } = render(<TestForm removeForm={removeForm} />);
+
+    await user.click(screen.getByText('Remove'));
+    expect(removeForm).toHaveBeenCalledWith(0);
+
+    rerender(<TestForm removeForm={removeForm} initialScope={{ uuid: 'scope-1' } as UserRoleScope} />);
+    expect(screen.queryByText('Remove')).not.toBeInTheDocument();
+  });
+});

package/src/components/users/manage-users/user-details/user-details.component.test.tsx

@@ -0,0 +1,135 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { getDefaultsFromConfigSchema, useConfig } from '@openmrs/esm-framework';
+import dayjs from 'dayjs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { configSchema } from '../../../../config-schema';
+import { type ProviderResponse, type UserResponse } from '../../../../types';
+import UserDetails from './user-details.component';
+
+const config = getDefaultsFromConfigSchema(configSchema);
+const attribute = (uuid: string, value: unknown) => ({
+  uuid: `${uuid}-${String(value)}`,
+  attributeType: { uuid, display: uuid },
+  value,
+});
+
+const user = {
+  uuid: 'user-1',
+  roles: [],
+} as UserResponse;
+
+function providerWith(attributes: Array<ReturnType<typeof attribute>>, gender = 'F') {
+  return {
+    uuid: 'provider-1',
+    person: { uuid: 'person-1', display: 'Alice Wanjiku', gender },
+    attributes,
+  } as ProviderResponse;
+}
+
+describe('UserDetails', () => {
+  beforeEach(() => {
+    vi.mocked(useConfig).mockReturnValue(config);
+  });
+
+  it('shows an unlicensed status, female gender, and the no-roles state', () => {
+    render(<UserDetails provider={providerWith([])} user={user} />);
+
+    expect(screen.getByText('Unlicensed')).toBeVisible();
+    expect(screen.getByText('Female')).toBeVisible();
+    expect(screen.getByText('No roles assigned')).toBeInTheDocument();
+  });
+
+  it('shows expired and expiring-soon license statuses', () => {
+    const { rerender } = render(
+      <UserDetails
+        provider={providerWith([
+          attribute(config.licenseNumberUuid, 'LIC-1'),
+          attribute(config.licenseExpiryDateUuid, dayjs().subtract(2, 'day').toISOString()),
+        ])}
+        user={user}
+      />,
+    );
+    expect(screen.getByText('License expired')).toBeVisible();
+
+    rerender(
+      <UserDetails
+        provider={providerWith([
+          attribute(config.licenseNumberUuid, 'LIC-1'),
+          attribute(config.licenseExpiryDateUuid, dayjs().add(2, 'day').toISOString()),
+        ])}
+        user={user}
+      />,
+    );
+    expect(screen.getByText('License expiring soon')).toBeVisible();
+  });
+
+  it('shows male gender and leaves unknown gender blank', () => {
+    const { rerender } = render(<UserDetails provider={providerWith([], 'M')} user={user} />);
+    expect(screen.getByText('Male')).toBeVisible();
+
+    rerender(<UserDetails provider={providerWith([], 'U')} user={user} />);
+    expect(screen.queryByText('Male')).not.toBeInTheDocument();
+    expect(screen.queryByText('Female')).not.toBeInTheDocument();
+  });
+
+  it('renders practice and provider identifiers with non-string attribute values', () => {
+    render(
+      <UserDetails
+        provider={providerWith([
+          attribute(config.licenseNumberUuid, 'LIC-1'),
+          attribute(config.practiceTypeUuid, 'private practice'),
+          attribute(config.providerUniqueIdentifierAttributeTypeUuid, 12345),
+          attribute(config.externalProviderIdentifierUuid, 'EXT-99'),
+        ])}
+        user={user}
+      />,
+    );
+
+    expect(screen.getByText('private practice')).toBeVisible();
+    expect(screen.getByText('12345')).toBeVisible();
+    expect(screen.getByText('EXT-99')).toBeVisible();
+  });
+
+  it('renders qualification, specialty, and cadre tags for an active provider', () => {
+    render(
+      <UserDetails
+        provider={providerWith([
+          attribute(config.licenseNumberUuid, 'LIC-1'),
+          attribute(config.licenseExpiryDateUuid, dayjs().add(30, 'day').toISOString()),
+          attribute(config.qualificationUuid, 'medical degree'),
+          attribute(config.specialtyUuid, 'cardiology'),
+          attribute(config.providerCadreUuid, 'consultant'),
+        ])}
+        user={user}
+      />,
+    );
+
+    expect(screen.getByText('Active')).toBeVisible();
+    expect(screen.getByText('Medical degree')).toBeVisible();
+    expect(screen.getByText('Cardiology')).toBeVisible();
+    expect(screen.getByText('Consultant')).toBeVisible();
+  });
+
+  it('renders assigned roles and falls back when a role has no description', () => {
+    render(
+      <UserDetails
+        provider={providerWith([])}
+        user={
+          {
+            ...user,
+            roles: [
+              { uuid: 'role-1', display: 'Inventory Manager', description: 'Manages inventory' },
+              { uuid: 'role-2', display: 'Provider', description: '' },
+            ],
+          } as UserResponse
+        }
+      />,
+    );
+
+    expect(screen.getByText('Inventory Manager')).toBeInTheDocument();
+    expect(screen.getByText('Manages inventory')).toBeInTheDocument();
+    expect(screen.getByText('Provider')).toBeInTheDocument();
+    expect(screen.getByText('No description available')).toBeInTheDocument();
+  });
+});