@pih/esm-audit-app 2.1.0

package/src/audit/encounter-audit.component.test.tsx

@@ -0,0 +1,242 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { SWRConfig } from 'swr';
+import { openmrsFetch, useConfig } from '@openmrs/esm-framework';
+import { type AuditEncounter, type AuditObs } from '../types';
+import EncounterAudit from './encounter-audit.component';
+
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+const mockUseConfig = jest.mocked(useConfig);
+
+const encounterCreated = '2026-09-01T11:09:00.000+0000';
+const dayAfterEncounter = '2026-09-02T08:30:00.000+0000';
+const creator = { uuid: 'user-1', display: 'Cos John' };
+
+const mockEncounter: AuditEncounter = {
+  uuid: 'enc-1',
+  display: 'COVID-19 Admission',
+  encounterDatetime: encounterCreated,
+  voided: false,
+  patient: {
+    uuid: 'patient-1',
+    display: 'Y2AHXV - Dave TestPatient',
+    identifiers: [{ uuid: 'id-1', identifier: 'Y2AHXV', preferred: true }],
+  },
+  location: { uuid: 'loc-1', display: 'CDI Klinik Ekstèn Jeneral' },
+  form: { uuid: 'form-1', display: 'COVID19 Admission', version: '1.0' },
+  encounterType: { uuid: 'type-1', display: 'COVID-19 Admission' },
+  visit: { uuid: 'visit-1', display: 'Clinic or Hospital Visit' },
+  encounterProviders: [
+    {
+      uuid: 'ep-1',
+      voided: false,
+      provider: { uuid: 'prov-1', display: 'Louidor Jean paul', identifier: 'MCPRPG' },
+      encounterRole: { uuid: 'role-1', display: 'Consulting Clinician' },
+    },
+  ],
+  auditInfo: { creator, dateCreated: encounterCreated },
+};
+
+const mockObs: Array<AuditObs> = [
+  {
+    uuid: 'obs-worker',
+    concept: { uuid: 'concept-worker', display: 'Health care worker' },
+    formFieldPath: 'covid.1-worker',
+    value: { uuid: 'concept-yes', display: 'Yes' },
+    auditInfo: { creator, dateCreated: encounterCreated },
+  },
+  {
+    uuid: 'obs-pulse-new',
+    concept: { uuid: 'concept-pulse', display: 'Pulse' },
+    formFieldPath: 'covid.2-pulse',
+    value: 68,
+    previousVersion: { uuid: 'obs-pulse-old', display: 'Pulse: 67' },
+    auditInfo: { creator, dateCreated: dayAfterEncounter },
+  },
+  {
+    uuid: 'obs-pulse-old',
+    concept: { uuid: 'concept-pulse', display: 'Pulse' },
+    formFieldPath: 'covid.2-pulse',
+    value: 67,
+    voided: true,
+    auditInfo: {
+      creator,
+      dateCreated: encounterCreated,
+      voidedBy: creator,
+      dateVoided: dayAfterEncounter,
+      voidReason: 'Corrected the reading',
+    },
+  },
+  {
+    uuid: 'obs-systolic',
+    concept: { uuid: 'concept-systolic', display: 'Systolic' },
+    formFieldPath: 'covid.3-systolic',
+    value: 123,
+    auditInfo: { creator, dateCreated: dayAfterEncounter },
+  },
+  {
+    uuid: 'obs-symptom-group',
+    concept: { uuid: 'concept-symptom-group', display: 'Sign/Symptom construct' },
+    formFieldPath: 'covid.4-symptom',
+    auditInfo: { creator, dateCreated: encounterCreated },
+  },
+  {
+    uuid: 'obs-symptom',
+    concept: { uuid: 'concept-symptom', display: 'Sign/Symptom name' },
+    obsGroup: { uuid: 'obs-symptom-group' },
+    value: { uuid: 'concept-fever', display: 'Fever' },
+    auditInfo: { creator, dateCreated: encounterCreated },
+  },
+];
+
+function mockRestApi({ encounter = mockEncounter, obs = mockObs } = {}) {
+  mockOpenmrsFetch.mockImplementation((url: string) => {
+    if (url.includes('/obs?')) {
+      return Promise.resolve({ data: { results: obs } }) as ReturnType<typeof openmrsFetch>;
+    }
+    return Promise.resolve({ data: encounter }) as ReturnType<typeof openmrsFetch>;
+  });
+}
+
+function renderEncounterAudit() {
+  const onBackToEncounters = jest.fn();
+  render(
+    <SWRConfig value={{ dedupingInterval: 0, provider: () => new Map() }}>
+      <EncounterAudit encounterUuid="enc-1" onBackToEncounters={onBackToEncounters} />
+    </SWRConfig>,
+  );
+  return onBackToEncounters;
+}
+
+function obsRowsFor(conceptName: string): Array<HTMLElement> {
+  return screen.getAllByRole('row').filter((row) => row.textContent?.startsWith(conceptName));
+}
+
+describe('<EncounterAudit />', () => {
+  beforeEach(() => {
+    mockUseConfig.mockReturnValue({ patientChartUrl: '${openmrsSpaBase}/patient/${patientUuid}/chart' });
+    mockRestApi();
+  });
+
+  it('summarises how the encounter was recorded', async () => {
+    renderEncounterAudit();
+
+    expect(await screen.findByText('CDI Klinik Ekstèn Jeneral')).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'Y2AHXV - Dave TestPatient' })).toHaveAttribute(
+      'href',
+      '/openmrs/spa/patient/patient-1/chart',
+    );
+    expect(screen.getByText('Y2AHXV')).toBeInTheDocument();
+    expect(screen.getByText('COVID19 Admission v1.0')).toBeInTheDocument();
+    expect(screen.getByText('Clinic or Hospital Visit')).toBeInTheDocument();
+    const createdByRow = screen.getAllByRole('row').find((row) => row.textContent?.startsWith('Created by'));
+    expect(createdByRow).toHaveTextContent('Cos John');
+  });
+
+  it('lists the providers on the encounter', async () => {
+    renderEncounterAudit();
+
+    const providerRow = (await screen.findAllByRole('row')).find((row) =>
+      row.textContent?.includes('Louidor Jean paul'),
+    );
+    expect(providerRow).toHaveTextContent('Consulting Clinician');
+    expect(providerRow).toHaveTextContent('MCPRPG');
+  });
+
+  it('shows an edited obs above the value it replaced', async () => {
+    renderEncounterAudit();
+    await screen.findByText('CDI Klinik Ekstèn Jeneral');
+
+    const pulseRows = obsRowsFor('Pulse');
+    expect(pulseRows).toHaveLength(2);
+    expect(pulseRows[0]).toHaveTextContent('68');
+    expect(pulseRows[0]).toHaveTextContent('Edited');
+    expect(pulseRows[0]).toHaveTextContent('was 67');
+    expect(pulseRows[1]).toHaveTextContent('67');
+    expect(pulseRows[1]).toHaveTextContent('Previous value');
+    expect(pulseRows[1]).toHaveTextContent('Corrected the reading');
+  });
+
+  it('flags an obs recorded after the encounter was created, and leaves the rest unflagged', async () => {
+    renderEncounterAudit();
+    await screen.findByText('CDI Klinik Ekstèn Jeneral');
+
+    expect(obsRowsFor('Systolic')[0]).toHaveTextContent('Added later');
+
+    const workerRow = obsRowsFor('Health care worker')[0];
+    expect(workerRow).toHaveTextContent('Yes');
+    expect(workerRow).not.toHaveTextContent('Added later');
+    expect(workerRow).not.toHaveTextContent('Edited');
+  });
+
+  it('nests obs group members under their group', async () => {
+    renderEncounterAudit();
+    await screen.findByText('CDI Klinik Ekstèn Jeneral');
+
+    expect(obsRowsFor('Sign/Symptom construct')).toHaveLength(1);
+    expect(obsRowsFor('Sign/Symptom name')[0]).toHaveTextContent('Fever');
+  });
+
+  it('hides deleted observations on request', async () => {
+    renderEncounterAudit();
+    await screen.findByText('CDI Klinik Ekstèn Jeneral');
+    expect(obsRowsFor('Pulse')).toHaveLength(2);
+
+    await userEvent.click(screen.getByRole('checkbox', { name: /show deleted observations/i }));
+
+    expect(obsRowsFor('Pulse')).toHaveLength(1);
+    expect(obsRowsFor('Pulse')[0]).toHaveTextContent('68');
+  });
+
+  it('shows concept descriptions on request', async () => {
+    mockRestApi({
+      obs: [
+        {
+          ...mockObs[0],
+          concept: {
+            uuid: 'concept-worker',
+            display: 'Health care worker',
+            descriptions: [{ description: 'Whether the patient works in health care', locale: 'en' }],
+          },
+        },
+      ],
+    });
+    renderEncounterAudit();
+    await screen.findByText('CDI Klinik Ekstèn Jeneral');
+
+    expect(screen.queryByText(/whether the patient works in health care/i)).not.toBeInTheDocument();
+
+    await userEvent.click(screen.getByRole('checkbox', { name: /show concept descriptions/i }));
+
+    expect(screen.getByText(/whether the patient works in health care/i)).toBeInTheDocument();
+  });
+
+  it('warns that a deleted encounter is being audited', async () => {
+    mockRestApi({
+      encounter: {
+        ...mockEncounter,
+        voided: true,
+        auditInfo: {
+          ...mockEncounter.auditInfo,
+          voidedBy: creator,
+          dateVoided: dayAfterEncounter,
+          voidReason: 'Entered on the wrong patient',
+        },
+      },
+    });
+    renderEncounterAudit();
+
+    expect(await screen.findByText(/this encounter has been deleted/i)).toBeInTheDocument();
+    expect(screen.getByText('Entered on the wrong patient')).toBeInTheDocument();
+  });
+
+  it('walks back up to the patient the encounter belongs to', async () => {
+    const onBackToEncounters = renderEncounterAudit();
+    await screen.findByText('CDI Klinik Ekstèn Jeneral');
+
+    await userEvent.click(screen.getByRole('button', { name: /back to encounters/i }));
+
+    expect(onBackToEncounters).toHaveBeenCalledWith('patient-1');
+  });
+});

package/src/audit/encounter-audit.component.tsx

@@ -0,0 +1,204 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  Button,
+  InlineNotification,
+  StructuredListBody,
+  StructuredListCell,
+  StructuredListRow,
+  StructuredListWrapper,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableHeader,
+  TableRow,
+  SkeletonText,
+  Tag,
+} from '@carbon/react';
+import { ArrowLeftIcon, ConfigurableLink, ErrorState, useConfig } from '@openmrs/esm-framework';
+import { type Config } from '../config-schema';
+import { type AuditEncounter } from '../types';
+import { formatAuditDatetime, formatUserAndDate } from './audit-format';
+import { getPreferredIdentifier, useEncounterAudit } from './audit.resource';
+import ObsAuditTable from './obs-audit-table.component';
+import styles from './audit.scss';
+
+interface EncounterAuditProps {
+  encounterUuid: string;
+  /** Called with the encounter's patient, so that a deep link can navigate back up the trail. */
+  onBackToEncounters(patientUuid: string | undefined): void;
+}
+
+interface SummaryRow {
+  label: string;
+  value: React.ReactNode;
+}
+
+/**
+ * Step three of the audit trail: everything known about how one encounter came to be — who created
+ * it, who last changed it, whether it has been deleted, and the full history of its observations.
+ */
+export default function EncounterAudit({ encounterUuid, onBackToEncounters }: EncounterAuditProps) {
+  const { t } = useTranslation();
+  const config = useConfig<Config>();
+  const { encounter, obsTree, error, isLoading } = useEncounterAudit(encounterUuid);
+
+  if (error) {
+    return (
+      <div className={styles.section}>
+        <BackButton onClick={() => onBackToEncounters(undefined)} />
+        <ErrorState error={error} headerTitle={t('encounterAudit', 'Encounter audit')} />
+      </div>
+    );
+  }
+
+  if (isLoading) {
+    return (
+      <div className={styles.section}>
+        <BackButton onClick={() => onBackToEncounters(undefined)} />
+        <SkeletonText heading paragraph role="progressbar" />
+      </div>
+    );
+  }
+
+  if (!encounter) {
+    return (
+      <div className={styles.section}>
+        <BackButton onClick={() => onBackToEncounters(undefined)} />
+        <p className={styles.emptyState}>{t('encounterNotFound', 'That encounter could not be found.')}</p>
+      </div>
+    );
+  }
+
+  const patientUuid = encounter.patient?.uuid;
+  const summaryRows: Array<SummaryRow> = [
+    {
+      label: t('patient', 'Patient'),
+      value: patientUuid ? (
+        <ConfigurableLink to={config.patientChartUrl} templateParams={{ patientUuid }}>
+          {encounter.patient?.display}
+        </ConfigurableLink>
+      ) : (
+        encounter.patient?.display
+      ),
+    },
+    { label: t('identifier', 'Identifier'), value: getPreferredIdentifier(encounter.patient) },
+    { label: t('encounterDate', 'Encounter date'), value: formatAuditDatetime(encounter.encounterDatetime) },
+    { label: t('location', 'Location'), value: encounter.location?.display },
+    { label: t('visit', 'Visit'), value: encounter.visit?.display },
+    { label: t('encounterType', 'Encounter type'), value: encounter.encounterType?.display },
+    { label: t('form', 'Form'), value: formatForm(encounter) },
+    {
+      label: t('createdBy', 'Created by'),
+      value: formatUserAndDate(encounter.auditInfo?.creator, encounter.auditInfo?.dateCreated),
+    },
+  ];
+
+  if (encounter.auditInfo?.changedBy) {
+    summaryRows.push({
+      label: t('changedBy', 'Changed by'),
+      value: formatUserAndDate(encounter.auditInfo.changedBy, encounter.auditInfo.dateChanged),
+    });
+  }
+
+  if (encounter.voided) {
+    summaryRows.push({
+      label: t('deletedBy', 'Deleted by'),
+      value: formatUserAndDate(encounter.auditInfo?.voidedBy, encounter.auditInfo?.dateVoided),
+    });
+    if (encounter.auditInfo?.voidReason) {
+      summaryRows.push({ label: t('deletionReason', 'Reason for deletion'), value: encounter.auditInfo.voidReason });
+    }
+  }
+
+  const providers = (encounter.encounterProviders ?? []).filter((encounterProvider) => !encounterProvider.voided);
+
+  return (
+    <div className={styles.section}>
+      <BackButton onClick={() => onBackToEncounters(patientUuid)} />
+      <div className={styles.contextHeader}>
+        <span className={styles.contextTitle}>
+          {encounter.encounterType?.display ?? t('encounter', 'Encounter')}
+          {encounter.voided ? <Tag type="red">{t('deleted', 'Deleted')}</Tag> : null}
+        </span>
+        <span className={styles.contextSubtitle}>
+          {[encounter.patient?.display, formatAuditDatetime(encounter.encounterDatetime)].filter(Boolean).join(' · ')}
+        </span>
+      </div>
+
+      {encounter.voided ? (
+        <InlineNotification
+          className={styles.inlineNotification}
+          hideCloseButton
+          kind="warning"
+          lowContrast
+          subtitle={t(
+            'encounterDeletedSubtitle',
+            'This encounter has been deleted. Its observations are shown as they were left.',
+          )}
+          title={t('encounterDeleted', 'Deleted encounter')}
+        />
+      ) : null}
+
+      <h3 className={styles.sectionHeading}>{t('encounterSummary', 'Encounter summary')}</h3>
+      <StructuredListWrapper className={styles.summaryList} isCondensed>
+        <StructuredListBody>
+          {summaryRows.map((row) => (
+            <StructuredListRow key={row.label}>
+              <StructuredListCell className={styles.summaryLabel} noWrap>
+                {row.label}
+              </StructuredListCell>
+              <StructuredListCell className={styles.summaryValue}>{row.value}</StructuredListCell>
+            </StructuredListRow>
+          ))}
+        </StructuredListBody>
+      </StructuredListWrapper>
+
+      <h3 className={styles.sectionHeading}>{t('providers', 'Providers')}</h3>
+      {providers.length === 0 ? (
+        <p className={styles.emptyState}>{t('noProviders', 'No providers are recorded for this encounter.')}</p>
+      ) : (
+        <TableContainer className={styles.tableContainer}>
+          <Table size="sm">
+            <TableHead>
+              <TableRow>
+                <TableHeader>{t('role', 'Role')}</TableHeader>
+                <TableHeader>{t('providerName', 'Provider name')}</TableHeader>
+                <TableHeader>{t('identifier', 'Identifier')}</TableHeader>
+              </TableRow>
+            </TableHead>
+            <TableBody>
+              {providers.map((encounterProvider) => (
+                <TableRow key={encounterProvider.uuid}>
+                  <TableCell>{encounterProvider.encounterRole?.display}</TableCell>
+                  <TableCell>{encounterProvider.provider?.display}</TableCell>
+                  <TableCell>{encounterProvider.provider?.identifier}</TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </TableContainer>
+      )}
+
+      <ObsAuditTable obsTree={obsTree} />
+    </div>
+  );
+}
+
+function BackButton({ onClick }: { onClick(): void }) {
+  const { t } = useTranslation();
+  return (
+    <Button className={styles.backButton} kind="ghost" onClick={onClick} renderIcon={ArrowLeftIcon} size="sm">
+      {t('backToEncounters', 'Back to encounters')}
+    </Button>
+  );
+}
+
+function formatForm(encounter: AuditEncounter): string | undefined {
+  if (!encounter.form?.display) {
+    return undefined;
+  }
+  return encounter.form.version ? `${encounter.form.display} v${encounter.form.version}` : encounter.form.display;
+}

package/src/audit/encounter-filters.component.tsx

@@ -0,0 +1,75 @@
+import React, { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button, ComboBox } from '@carbon/react';
+import { OpenmrsDateRangePicker } from '@openmrs/esm-framework';
+import { type AuditPatient, type OpenmrsResourceRef } from '../types';
+import { usePatientEncounterTypes } from './audit.resource';
+import { type EncounterFilters, fromDateKey, hasActiveFilters, toDateKey } from './encounter-filters';
+import styles from './audit.scss';
+
+interface EncounterFiltersBarProps {
+  patient: AuditPatient | undefined;
+  includeDeleted: boolean;
+  filters: EncounterFilters;
+  onChange(filters: EncounterFilters): void;
+}
+
+/**
+ * Narrows a patient's encounter list by encounter type and by the date the encounter happened.
+ * The types on offer are the ones this patient's encounters actually use.
+ */
+export default function EncounterFiltersBar({ patient, includeDeleted, filters, onChange }: EncounterFiltersBarProps) {
+  const { t } = useTranslation();
+  const { encounterTypes, isLoading } = usePatientEncounterTypes(patient, includeDeleted);
+
+  const today = useMemo(() => new Date(), []);
+
+  /**
+   * Hiding deleted encounters again can take the chosen type out of the list. Keeping it on the
+   * list means the filter that is in force is still the one shown, and can still be changed.
+   */
+  const items = useMemo(() => {
+    const selected = filters.encounterType;
+    if (selected && !encounterTypes.some((encounterType) => encounterType.uuid === selected.uuid)) {
+      return [...encounterTypes, selected];
+    }
+    return encounterTypes;
+  }, [encounterTypes, filters.encounterType]);
+
+  const dateRange = useMemo<[Date | null, Date | null]>(
+    () => [fromDateKey(filters.fromDate), fromDateKey(filters.toDate)],
+    [filters.fromDate, filters.toDate],
+  );
+
+  return (
+    <div className={styles.filters}>
+      <ComboBox
+        className={styles.filterControl}
+        disabled={isLoading || items.length === 0}
+        id="encounter-type-filter"
+        items={items}
+        itemToString={(encounterType: OpenmrsResourceRef | null) => encounterType?.display ?? ''}
+        onChange={({ selectedItem }: { selectedItem: OpenmrsResourceRef | null }) =>
+          onChange({ ...filters, encounterType: selectedItem ?? undefined })
+        }
+        placeholder={t('allEncounterTypes', 'All encounter types')}
+        selectedItem={filters.encounterType ?? null}
+        size="sm"
+        titleText={t('encounterType', 'Encounter type')}
+      />
+      <OpenmrsDateRangePicker
+        className={styles.filterControl}
+        labelText={t('encounterDateRange', 'Encounter date range')}
+        maxDate={today}
+        onChange={([from, to]) => onChange({ ...filters, fromDate: toDateKey(from), toDate: toDateKey(to) })}
+        size="sm"
+        value={dateRange}
+      />
+      {hasActiveFilters(filters) ? (
+        <Button className={styles.clearFilters} kind="ghost" onClick={() => onChange({})} size="sm">
+          {t('clearFilters', 'Clear filters')}
+        </Button>
+      ) : null}
+    </div>
+  );
+}

package/src/audit/encounter-filters.test.ts

@@ -0,0 +1,119 @@
+import { type AuditEncounter } from '../types';
+import {
+  buildEncounterFilterQuery,
+  distinctEncounterTypes,
+  fromDateKey,
+  hasActiveFilters,
+  matchesEncounterFilters,
+  toDateKey,
+} from './encounter-filters';
+
+const consultationType = { uuid: 'type-consultation', display: 'Oncology Consultation' };
+const checkinType = { uuid: 'type-checkin', display: 'Inscription' };
+
+const consultation: AuditEncounter = {
+  uuid: 'enc-1',
+  encounterDatetime: '2026-04-18T09:00:00.000+0000',
+  encounterType: consultationType,
+};
+
+describe('date keys', () => {
+  it('reads the calendar date a moment falls on', () => {
+    expect(toDateKey(new Date(2026, 3, 18, 9, 0))).toBe('2026-04-18');
+    expect(toDateKey(new Date(2026, 0, 5))).toBe('2026-01-05');
+  });
+
+  it('has nothing to say about a missing or unparseable date', () => {
+    expect(toDateKey(null)).toBeUndefined();
+    expect(toDateKey(undefined)).toBeUndefined();
+    expect(toDateKey(new Date('nonsense'))).toBeUndefined();
+  });
+
+  it('round-trips back to local midnight, not to UTC midnight', () => {
+    const date = fromDateKey('2026-04-18');
+
+    expect(date?.getFullYear()).toBe(2026);
+    expect(date?.getMonth()).toBe(3);
+    expect(date?.getDate()).toBe(18);
+    expect(date?.getHours()).toBe(0);
+    expect(toDateKey(date)).toBe('2026-04-18');
+  });
+
+  it('has nothing to round-trip when no date is set', () => {
+    expect(fromDateKey(undefined)).toBeNull();
+    expect(fromDateKey('')).toBeNull();
+  });
+});
+
+describe('hasActiveFilters', () => {
+  it('knows when a filter is set', () => {
+    expect(hasActiveFilters({})).toBe(false);
+    expect(hasActiveFilters({ encounterType: consultationType })).toBe(true);
+    expect(hasActiveFilters({ fromDate: '2026-04-01' })).toBe(true);
+    expect(hasActiveFilters({ toDate: '2026-04-30' })).toBe(true);
+  });
+});
+
+describe('buildEncounterFilterQuery', () => {
+  it('sends nothing when nothing is filtered', () => {
+    expect(buildEncounterFilterQuery({})).toBe('');
+  });
+
+  it('asks the server for one encounter type', () => {
+    expect(buildEncounterFilterQuery({ encounterType: consultationType })).toBe('&encounterType=type-consultation');
+  });
+
+  it('covers whole days at both ends of the range, in the server’s own time zone', () => {
+    expect(buildEncounterFilterQuery({ fromDate: '2026-04-01', toDate: '2026-04-30' })).toBe(
+      '&fromdate=2026-04-01T00:00:00&todate=2026-04-30T23:59:59',
+    );
+  });
+});
+
+describe('matchesEncounterFilters', () => {
+  it('keeps everything when nothing is filtered', () => {
+    expect(matchesEncounterFilters(consultation, {})).toBe(true);
+  });
+
+  it('keeps only the chosen encounter type', () => {
+    expect(matchesEncounterFilters(consultation, { encounterType: consultationType })).toBe(true);
+    expect(matchesEncounterFilters(consultation, { encounterType: checkinType })).toBe(false);
+  });
+
+  it('treats both ends of the date range as inclusive', () => {
+    const day = toDateKey(new Date(consultation.encounterDatetime));
+
+    expect(matchesEncounterFilters(consultation, { fromDate: day, toDate: day })).toBe(true);
+    expect(matchesEncounterFilters(consultation, { fromDate: '2026-04-01', toDate: '2026-04-30' })).toBe(true);
+    expect(matchesEncounterFilters(consultation, { fromDate: '2026-04-19' })).toBe(false);
+    expect(matchesEncounterFilters(consultation, { toDate: '2026-04-17' })).toBe(false);
+  });
+
+  it('requires every filter to match', () => {
+    expect(matchesEncounterFilters(consultation, { encounterType: consultationType, fromDate: '2026-04-19' })).toBe(
+      false,
+    );
+  });
+
+  it('excludes an encounter with no date once a date range is set', () => {
+    expect(matchesEncounterFilters({ uuid: 'enc-2' }, { fromDate: '2026-04-01' })).toBe(false);
+    expect(matchesEncounterFilters({ uuid: 'enc-2' }, {})).toBe(true);
+  });
+});
+
+describe('distinctEncounterTypes', () => {
+  it('collects each type a patient has once, sorted by name', () => {
+    expect(
+      distinctEncounterTypes([
+        { uuid: 'enc-1', encounterType: consultationType },
+        { uuid: 'enc-2', encounterType: checkinType },
+        { uuid: 'enc-3', encounterType: { ...consultationType } },
+      ]),
+    ).toEqual([checkinType, consultationType]);
+  });
+
+  it('skips encounters with no type, and copes with none at all', () => {
+    expect(distinctEncounterTypes([{ uuid: 'enc-1' }])).toEqual([]);
+    expect(distinctEncounterTypes([])).toEqual([]);
+  });
+});