@kenyaemr/esm-admin-app 5.4.4-pre.299 → 5.4.4-pre.3

package/src/components/global-property/table/global-property-table.scss

@@ -0,0 +1,34 @@
+@use '@carbon/layout';
+
+.dataTableContainer {
+  height: 100%;
+  margin: layout.$layout-01;
+}
+
+.tableHeaderSection {
+  display: flex;
+  align-items: center;
+}
+
+.actionsCell {
+  display: flex;
+  justify-content: flex-end;
+}
+
+.visuallyHidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+.emptyState {
+  padding: 2rem;
+  text-align: center;
+  color: var(--cds-text-secondary);
+}

package/src/components/global-property/table/global-property-table.test.tsx

@@ -0,0 +1,198 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import GlobalPropertyTable from './global-property-table.component';
+
+const mockGoTo = vi.fn();
+const mockMutate = vi.fn();
+const mockLaunchWorkspace2 = vi.fn();
+const mockShowModal = vi.fn(() => vi.fn());
+
+vi.mock('react-i18next', () => ({
+  useTranslation: () => ({ t: (_key: string, fallback: string, opts?: Record<string, unknown>) => fallback }),
+}));
+
+vi.mock('@openmrs/esm-framework', () => ({
+  useLayoutType: vi.fn(() => 'desktop'),
+  isDesktop: vi.fn(() => true),
+  launchWorkspace2: (...args: unknown[]) => mockLaunchWorkspace2(...args),
+  showModal: (...args: unknown[]) => mockShowModal(...args),
+  useDebounce: vi.fn((val: string) => val),
+  usePaginationInfo: vi.fn(() => ({ pageSizes: [10, 20, 50] })),
+  ErrorCard: ({ headerTitle }: { headerTitle: string }) => <div data-testid="error-card">{headerTitle}</div>,
+}));
+
+vi.mock('@carbon/react', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@carbon/react')>();
+  return {
+    ...original,
+    DataTable: ({
+      children,
+      rows,
+      headers,
+    }: {
+      children: (props: any) => React.ReactNode;
+      rows: any[];
+      headers: any[];
+    }) => {
+      if (typeof children === 'function') {
+        const renderRows = rows.map((row) => ({
+          ...row,
+          cells: headers.map((h) => ({
+            id: `${row.id}:${h.key}`,
+            value: row[h.key],
+            info: { header: h.key },
+          })),
+        }));
+        return children({
+          rows: renderRows,
+          headers,
+          getTableProps: () => ({}),
+          getHeaderProps: ({ header }: any) => ({ key: header.key }),
+          getRowProps: ({ row }: any) => ({ key: row.id }),
+          getCellProps: ({ cell }: any) => ({ key: cell.id }),
+        });
+      }
+      return children;
+    },
+    Button: ({ children, onClick, disabled, iconDescription, hasIconOnly, type }: any) => (
+      <button
+        onClick={onClick}
+        disabled={disabled}
+        aria-label={hasIconOnly ? iconDescription : undefined}
+        type={type || 'button'}>
+        {hasIconOnly ? null : children}
+      </button>
+    ),
+  };
+});
+
+vi.mock('../hooks/useGlobalProperty', () => ({
+  useGlobalProperties: vi.fn(),
+}));
+
+import { useGlobalProperties } from '../hooks/useGlobalProperty';
+
+const mockProperties = [
+  { uuid: 'uuid-1', property: 'setting.one', value: 'value1', description: 'First setting' },
+  { uuid: 'uuid-2', property: 'setting.two', value: 'value2', description: 'Second setting' },
+];
+
+function setupMock(overrides = {}) {
+  (useGlobalProperties as ReturnType<typeof vi.fn>).mockReturnValue({
+    isLoading: false,
+    data: mockProperties,
+    error: null,
+    goTo: mockGoTo,
+    currentPage: 1,
+    totalCount: 2,
+    mutate: mockMutate,
+    ...overrides,
+  });
+}
+
+describe('GlobalPropertyTable', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('shows a loading skeleton while data is loading', () => {
+    setupMock({ isLoading: true, data: [] });
+    render(<GlobalPropertyTable />);
+    expect(screen.getByRole('table')).toBeInTheDocument();
+  });
+
+  it('shows empty state message when no properties exist', () => {
+    setupMock({ data: [] });
+    render(<GlobalPropertyTable />);
+    expect(screen.getByText('No global properties to display')).toBeInTheDocument();
+  });
+
+  it('renders the table with property and value columns', () => {
+    setupMock();
+    render(<GlobalPropertyTable />);
+    expect(screen.getByText('Property')).toBeInTheDocument();
+    expect(screen.getByText('Value')).toBeInTheDocument();
+  });
+
+  it('renders all global property rows', () => {
+    setupMock();
+    render(<GlobalPropertyTable />);
+    expect(screen.getByText('setting.one')).toBeInTheDocument();
+    expect(screen.getByText('value1')).toBeInTheDocument();
+    expect(screen.getByText('setting.two')).toBeInTheDocument();
+    expect(screen.getByText('value2')).toBeInTheDocument();
+  });
+
+  it('opens the add workspace when "Add new global property" button is clicked', () => {
+    setupMock();
+    render(<GlobalPropertyTable />);
+    fireEvent.click(screen.getByText('Add new global property'));
+    expect(mockLaunchWorkspace2).toHaveBeenCalledWith(
+      'global-property-workspace',
+      expect.objectContaining({
+        systemSetting: undefined,
+        mutateGlobalProperty: mockMutate,
+      }),
+    );
+  });
+
+  it('opens the edit workspace with the correct property when edit is clicked', () => {
+    setupMock();
+    render(<GlobalPropertyTable />);
+    const editButtons = screen.getAllByRole('button', { name: 'Edit' });
+    fireEvent.click(editButtons[0]);
+    expect(mockLaunchWorkspace2).toHaveBeenCalledWith(
+      'global-property-workspace',
+      expect.objectContaining({
+        systemSetting: mockProperties[0],
+      }),
+    );
+  });
+
+  it('opens the delete modal with the correct property when delete is clicked', () => {
+    setupMock();
+    render(<GlobalPropertyTable />);
+    const deleteButtons = screen.getAllByRole('button', { name: 'Delete' });
+    fireEvent.click(deleteButtons[0]);
+    expect(mockShowModal).toHaveBeenCalledWith(
+      'delete-global-property-modal',
+      expect.objectContaining({
+        property: 'setting.one',
+        uuid: 'uuid-1',
+      }),
+    );
+  });
+
+  it('filters results and resets to page 1 when user types in the search box', async () => {
+    setupMock({ currentPage: 2 });
+    render(<GlobalPropertyTable />);
+    const searchInput = screen.getByPlaceholderText('Search global property by name');
+    fireEvent.change(searchInput, { target: { value: 'setting' } });
+    await waitFor(() => {
+      expect(mockGoTo).toHaveBeenCalledWith(1);
+    });
+  });
+
+  it('shows "no matching" message when search yields no results', () => {
+    setupMock({ data: [] });
+    render(<GlobalPropertyTable />);
+    const searchInput = screen.getByPlaceholderText('Search global property by name');
+    fireEvent.change(searchInput, { target: { value: 'nonexistent' } });
+    expect(screen.getByText('No global properties match your search')).toBeInTheDocument();
+  });
+
+  it('renders an error card when the hook returns an error', () => {
+    setupMock({ error: new Error('Network error'), data: [] });
+    render(<GlobalPropertyTable />);
+    expect(screen.getByTestId('error-card')).toBeInTheDocument();
+    expect(screen.getByText('Global property')).toBeInTheDocument();
+  });
+
+  it('renders a search input for filtering properties', () => {
+    setupMock();
+    render(<GlobalPropertyTable />);
+    expect(screen.getByPlaceholderText('Search global property by name')).toBeInTheDocument();
+  });
+});

package/src/components/global-property/workspace/global-property-form-schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { TFunction } from 'i18next';
+
+export const createGlobalPropertyFormSchema = (t: TFunction) =>
+  z.object({
+    property: z.string().min(1, { message: t('gpPropertyNameRequired', 'Property name is required') }),
+    description: z.string().optional(),
+    datatypeClassname: z.string().optional(),
+    datatypeConfig: z.string().optional(),
+    preferredHandlerClassname: z.string().optional(),
+    handlerConfig: z.string().nullable().optional(),
+    value: z.string().min(1, { message: t('gpValueRequired', 'Value is required') }),
+  });
+
+export type GlobalPropertyFormType = z.infer<ReturnType<typeof createGlobalPropertyFormSchema>>;
+
+export const openmrsCustomDatatypes = [
+  'org.openmrs.customdatatype.datatype.BooleanDatatype',
+  'org.openmrs.customdatatype.datatype.DateDatatype',
+  'org.openmrs.customdatatype.datatype.DateTimeDatatype',
+  'org.openmrs.customdatatype.datatype.FloatDatatype',
+  'org.openmrs.customdatatype.datatype.FreeTextDatatype',
+  'org.openmrs.customdatatype.datatype.LongFreeTextDatatype',
+  'org.openmrs.customdatatype.datatype.RegexValidatedTextDatatype',
+  'org.openmrs.customdatatype.datatype.SpecifiedTextOptionsDatatype',
+  'org.openmrs.customdatatype.datatype.ConceptDatatype',
+  'org.openmrs.customdatatype.datatype.LocationDatatype',
+  'org.openmrs.customdatatype.datatype.ProgramDatatype',
+  'org.openmrs.customdatatype.datatype.ProviderDatatype',
+];
+
+export type OpenmrsCustomDatatype = (typeof openmrsCustomDatatypes)[number];

package/src/components/global-property/workspace/global-property.workspace.scss

@@ -0,0 +1,40 @@
+@use '@carbon/colors';
+@use '@carbon/layout';
+
+.form {
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  height: 100%;
+}
+
+.formContainer {
+  margin: layout.$spacing-05;
+  display: flex;
+  flex-direction: column;
+  gap: layout.$spacing-05;
+  overflow-y: auto;
+}
+
+.tablet {
+  padding: layout.$spacing-06 layout.$spacing-05;
+  background-color: colors.$white;
+}
+
+.desktop {
+  padding: 0;
+
+  & button {
+    max-width: 50% !important;
+  }
+}
+
+.buttonContainer {
+  max-width: 50%;
+}
+
+.inlineLoading {
+  display: flex;
+  align-items: center;
+  gap: layout.$spacing-03;
+}

package/src/components/global-property/workspace/global-property.workspace.test.tsx

@@ -0,0 +1,172 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import GlobalPropertyWorkspace from './global-property.workspace';
+
+const mockShowSnackbar = vi.fn();
+const mockSaveOrUpdateGlobalProperty = vi.fn();
+const mockCloseWorkspace = vi.fn();
+const mockMutateGlobalProperty = vi.fn();
+
+vi.mock('react-i18next', () => ({
+  useTranslation: () => ({ t: (_key: string, fallback: string) => fallback }),
+}));
+
+vi.mock('@openmrs/esm-framework', () => ({
+  useLayoutType: vi.fn(() => 'desktop'),
+  showSnackbar: (...args: unknown[]) => mockShowSnackbar(...args),
+  ResponsiveWrapper: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+  Workspace2: ({ children, title }: { children: React.ReactNode; title: string }) => (
+    <div>
+      <h2>{title}</h2>
+      {children}
+    </div>
+  ),
+}));
+
+vi.mock('../hooks/useGlobalProperty', () => ({
+  saveOrUpdateGlobalProperty: (...args: unknown[]) => mockSaveOrUpdateGlobalProperty(...args),
+}));
+
+vi.mock('@hookform/resolvers/zod', () => ({
+  zodResolver: () => async (values: unknown) => ({ values, errors: {} }),
+}));
+
+const baseProps = {
+  closeWorkspace: mockCloseWorkspace,
+  workspaceProps: {
+    systemSetting: null,
+    mutateGlobalProperty: mockMutateGlobalProperty,
+  },
+};
+
+describe('GlobalPropertyWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('shows "Add global property" title in add mode', () => {
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+    expect(screen.getByText('Add global property')).toBeInTheDocument();
+  });
+
+  it('shows "Edit global property" title when editing an existing property', () => {
+    const props = {
+      ...baseProps,
+      workspaceProps: {
+        systemSetting: { uuid: 'uuid-1', property: 'setting.one', value: 'value1' },
+        mutateGlobalProperty: mockMutateGlobalProperty,
+      },
+    };
+    render(<GlobalPropertyWorkspace {...props} />);
+    expect(screen.getByText('Edit global property')).toBeInTheDocument();
+  });
+
+  it('pre-fills form fields when editing an existing property', () => {
+    const props = {
+      ...baseProps,
+      workspaceProps: {
+        systemSetting: { uuid: 'uuid-1', property: 'my.setting', value: 'my-value' },
+        mutateGlobalProperty: mockMutateGlobalProperty,
+      },
+    };
+    render(<GlobalPropertyWorkspace {...props} />);
+    expect(screen.getByDisplayValue('my.setting')).toBeInTheDocument();
+    expect(screen.getByDisplayValue('my-value')).toBeInTheDocument();
+  });
+
+  it('disables the property field when editing an existing property', () => {
+    const props = {
+      ...baseProps,
+      workspaceProps: {
+        systemSetting: { uuid: 'uuid-1', property: 'setting.one', value: 'value1' },
+        mutateGlobalProperty: mockMutateGlobalProperty,
+      },
+    };
+    render(<GlobalPropertyWorkspace {...props} />);
+    expect(screen.getByLabelText(/Property/i)).toBeDisabled();
+  });
+
+  it('enables the property field in add mode', () => {
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+    expect(screen.getByLabelText(/Property/i)).not.toBeDisabled();
+  });
+
+  it('renders the Cancel and Save & close buttons', () => {
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+    expect(screen.getByText('Cancel')).toBeInTheDocument();
+    expect(screen.getByText('Save & close')).toBeInTheDocument();
+  });
+
+  it('calls closeWorkspace when Cancel is clicked', () => {
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+    fireEvent.click(screen.getByText('Cancel'));
+    expect(mockCloseWorkspace).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows validation error when form is submitted with empty required fields', async () => {
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+    const saveButton = screen.getByText('Save & close');
+    fireEvent.click(saveButton);
+    await waitFor(() => {
+      expect(mockSaveOrUpdateGlobalProperty).not.toHaveBeenCalled();
+    });
+  });
+
+  it('saves a new property with the entered values', async () => {
+    mockSaveOrUpdateGlobalProperty.mockResolvedValue(undefined);
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+
+    await userEvent.type(screen.getByLabelText(/Property/i), 'new.setting');
+    await userEvent.type(screen.getByLabelText(/Value/i), 'new-value');
+
+    fireEvent.submit(screen.getByLabelText(/Property/i).closest('form')!);
+
+    await waitFor(() => {
+      expect(mockSaveOrUpdateGlobalProperty).toHaveBeenCalledWith(
+        expect.objectContaining({ property: 'new.setting', value: 'new-value' }),
+        undefined,
+      );
+    });
+  });
+
+  it('shows a success snackbar and closes workspace after saving', async () => {
+    mockSaveOrUpdateGlobalProperty.mockResolvedValue(undefined);
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+
+    await userEvent.type(screen.getByLabelText(/Property/i), 'new.setting');
+    await userEvent.type(screen.getByLabelText(/Value/i), 'new-value');
+
+    fireEvent.submit(screen.getByLabelText(/Property/i).closest('form')!);
+
+    await waitFor(() => {
+      expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' }));
+      expect(mockMutateGlobalProperty).toHaveBeenCalled();
+      expect(mockCloseWorkspace).toHaveBeenCalled();
+    });
+  });
+
+  it('shows an error snackbar when saving fails', async () => {
+    mockSaveOrUpdateGlobalProperty.mockRejectedValue(new Error('Failed to save'));
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+
+    await userEvent.type(screen.getByLabelText(/Property/i), 'new.setting');
+    await userEvent.type(screen.getByLabelText(/Value/i), 'new-value');
+
+    fireEvent.submit(screen.getByLabelText(/Property/i).closest('form')!);
+
+    await waitFor(() => {
+      expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'error' }));
+      expect(mockCloseWorkspace).not.toHaveBeenCalled();
+    });
+  });
+
+  it('renders optional fields: description, datatype config, handler config', () => {
+    render(<GlobalPropertyWorkspace {...baseProps} />);
+    expect(screen.getByLabelText(/Description/i)).toBeInTheDocument();
+    expect(screen.getByLabelText(/Datatype config/i)).toBeInTheDocument();
+    expect(screen.getByLabelText(/Handler config/i)).toBeInTheDocument();
+  });
+});