@pih/esm-audit-app 2.1.1-pre.144 → 2.1.1-pre.151

package/src/audit/date-range.ts

@@ -0,0 +1,120 @@
+/**
+ * A range of calendar dates, held as `YYYY-MM-DD` rather than as instants because that is what
+ * someone picking a date means. Both ends are inclusive.
+ */
+export interface DateRange {
+  fromDate?: string;
+  toDate?: string;
+}
+
+function pad(value: number): string {
+  return String(value).padStart(2, '0');
+}
+
+/** The calendar date a `Date` falls on, in the browser's time zone. */
+export function toDateKey(date: Date | null | undefined): string | undefined {
+  if (!date || Number.isNaN(date.getTime())) {
+    return undefined;
+  }
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/** Local midnight on a calendar date, for handing a stored range back to a date picker. */
+export function fromDateKey(key: string | undefined): Date | null {
+  if (!key) {
+    return null;
+  }
+  const [year, month, day] = key.split('-').map(Number);
+  if (!year || !month || !day) {
+    return null;
+  }
+  return new Date(year, month - 1, day);
+}
+
+/** The part of a react-aria date value `fromPickerRange` reads, whatever calendar it is in. */
+interface PickerDate {
+  toDate(timeZone: string): Date;
+}
+
+/**
+ * The earliest year the picker accepts; it is the framework's floor for a date picker with no
+ * `minDate`, which the picker flags as out of range but reports all the same.
+ */
+const EARLIEST_PICKER_YEAR = 1793;
+
+/**
+ * The range an `OpenmrsDateRangePicker` reports through `onChangeRaw`.
+ *
+ * Its `onChange` cannot be used: react-aria reports `null` until both ends of the range are
+ * complete, which is on every keystroke while typing the first date, and the framework's `onChange`
+ * reads `start` off that `null` and throws. An incomplete range is treated as no range at all.
+ *
+ * So is one the picker would reject. Once the first date is in, react-aria reports a complete range
+ * on every keystroke of the last year typed, as years 2, 20 and 202 on the way to 2026, and those
+ * are no more the range someone means than a half-typed one is.
+ */
+export function fromPickerRange(
+  range: { start?: PickerDate | null; end?: PickerDate | null } | null | undefined,
+): DateRange {
+  const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const start = range?.start?.toDate(timeZone);
+  const end = range?.end?.toDate(timeZone);
+  if (!start || !end || start > end || start.getFullYear() < EARLIEST_PICKER_YEAR) {
+    return {};
+  }
+  return { fromDate: toDateKey(start), toDate: toDateKey(end) };
+}
+
+/**
+ * What to seed an `OpenmrsDateRangePicker` with, as its `defaultValue`: nothing at all when no range
+ * is set.
+ *
+ * The picker must be left uncontrolled. React-aria keeps a half-typed range to one side, and only
+ * shows it while the picker's value is empty; the framework hands an empty `value` on as a range with
+ * two empty ends rather than as no range, which hides it, so the day and month typed so far are
+ * wiped the moment the year completes the first date. Remount the picker (with a `key`) to clear it.
+ */
+export function toPickerDefault(range: DateRange): [Date | null, Date | null] | undefined {
+  return hasDateRange(range) ? [fromDateKey(range.fromDate), fromDateKey(range.toDate)] : undefined;
+}
+
+export function hasDateRange(range: DateRange): boolean {
+  return Boolean(range.fromDate || range.toDate);
+}
+
+/**
+ * What each pihapps audit endpoint calls its date bounds. Both take a separate range per column,
+ * so a caller names the one it means: the obs streams bound the action each searched on, and the
+ * provider view is asking when encounters happened, hence `encounterDatetime`.
+ */
+export const OBS_CREATED_DATE_PARAMS = { from: 'createdOnOrAfter', to: 'createdOnOrBefore' } as const;
+export const OBS_VOIDED_DATE_PARAMS = { from: 'voidedOnOrAfter', to: 'voidedOnOrBefore' } as const;
+export const ENCOUNTER_DATE_PARAMS = {
+  from: 'encounterDatetimeOnOrAfter',
+  to: 'encounterDatetimeOnOrBefore',
+} as const;
+
+interface DateParamNames {
+  from: string;
+  to: string;
+}
+
+/**
+ * The date query one of those endpoints understands. `params` names its two bounds; there is no
+ * default, since no two of them agree any more.
+ *
+ * Bare dates are sent deliberately: those endpoints read a date-only upper bound as the whole of
+ * that day, so there is no need to spell out a time to avoid an inclusive bound matching only
+ * midnight. They read both ends against whatever the search is about: the audit action where one is
+ * named, and the encounter's own datetime for a provider search.
+ */
+export function buildAuditDateQuery(range: DateRange, params: DateParamNames): string {
+  let query = '';
+  if (range.fromDate) {
+    query += `&${params.from}=${range.fromDate}`;
+  }
+  if (range.toDate) {
+    query += `&${params.to}=${range.toDate}`;
+  }
+  return query;
+}

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

@@ -1,26 +1,34 @@
-import React, { useMemo } from 'react';
+import React, { useMemo, useState } 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 { type OpenmrsResourceRef } from '../types';
+import { fromPickerRange, toPickerDefault } from './date-range';
+import { type EncounterFilters, hasActiveFilters } from './encounter-filters';
 import styles from './audit.scss';
 
 interface EncounterFiltersBarProps {
-  patient: AuditPatient | undefined;
-  includeDeleted: boolean;
+  /**
+   * The types to offer. Supplied rather than fetched, because the right set depends on the list
+   * being filtered: a patient's own types where they can be known, every type in the system where
+   * they cannot.
+   */
+  encounterTypes: Array<OpenmrsResourceRef>;
+  isLoadingTypes: 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.
+ * Narrows an encounter list by encounter type and by the date the encounter happened.
  */
-export default function EncounterFiltersBar({ patient, includeDeleted, filters, onChange }: EncounterFiltersBarProps) {
+export default function EncounterFiltersBar({
+  encounterTypes,
+  isLoadingTypes,
+  filters,
+  onChange,
+}: EncounterFiltersBarProps) {
   const { t } = useTranslation();
-  const { encounterTypes, isLoading } = usePatientEncounterTypes(patient, includeDeleted);
 
   const today = useMemo(() => new Date(), []);
 
@@ -36,16 +44,14 @@ export default function EncounterFiltersBar({ patient, includeDeleted, filters,
     return encounterTypes;
   }, [encounterTypes, filters.encounterType]);
 
-  const dateRange = useMemo<[Date | null, Date | null]>(
-    () => [fromDateKey(filters.fromDate), fromDateKey(filters.toDate)],
-    [filters.fromDate, filters.toDate],
-  );
+  // bumped to clear the range picker, which has to be left to hold its own value
+  const [datePickerKey, setDatePickerKey] = useState(0);
 
   return (
     <div className={styles.filters}>
       <ComboBox
         className={styles.filterControl}
-        disabled={isLoading || items.length === 0}
+        disabled={isLoadingTypes || items.length === 0}
         id="encounter-type-filter"
         items={items}
         itemToString={(encounterType: OpenmrsResourceRef | null) => encounterType?.display ?? ''}
@@ -59,14 +65,30 @@ export default function EncounterFiltersBar({ patient, includeDeleted, filters,
       />
       <OpenmrsDateRangePicker
         className={styles.filterControl}
+        defaultValue={toPickerDefault(filters)}
+        id="encounter-date-range-filter"
         labelText={t('encounterDateRange', 'Encounter date range')}
         maxDate={today}
-        onChange={([from, to]) => onChange({ ...filters, fromDate: toDateKey(from), toDate: toDateKey(to) })}
+        onChangeRaw={(range) => {
+          const { fromDate, toDate } = fromPickerRange(range);
+          // the picker reports on keystrokes that leave the range as it was, and a new filters object
+          // would send the list back to its first page for nothing
+          if (fromDate !== filters.fromDate || toDate !== filters.toDate) {
+            onChange({ ...filters, fromDate, toDate });
+          }
+        }}
+        key={datePickerKey}
         size="sm"
-        value={dateRange}
       />
       {hasActiveFilters(filters) ? (
-        <Button className={styles.clearFilters} kind="ghost" onClick={() => onChange({})} size="sm">
+        <Button
+          className={styles.clearFilters}
+          kind="ghost"
+          onClick={() => {
+            setDatePickerKey((key) => key + 1);
+            onChange({});
+          }}
+          size="sm">
           {t('clearFilters', 'Clear filters')}
         </Button>
       ) : null}

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

@@ -1,11 +1,10 @@
 import { type AuditEncounter } from '../types';
+import { fromDateKey, toDateKey } from './date-range';
 import {
   buildEncounterFilterQuery,
   distinctEncounterTypes,
-  fromDateKey,
   hasActiveFilters,
   matchesEncounterFilters,
-  toDateKey,
 } from './encounter-filters';
 
 const consultationType = { uuid: 'type-consultation', display: 'Oncology Consultation' };

package/src/audit/encounter-filters.ts

@@ -1,19 +1,18 @@
 import { type AuditEncounter, type OpenmrsResourceRef } from '../types';
+import { type DateRange, toDateKey } from './date-range';
 
 /**
  * The filters an auditor can narrow a patient's encounter list by. Dates are held as calendar
  * dates (`YYYY-MM-DD`) rather than instants, because that is what someone picking a date means,
  * and both bounds are inclusive.
  */
-export interface EncounterFilters {
+export interface EncounterFilters extends DateRange {
   /**
    * The whole reference rather than just the uuid, so that the chosen type stays displayable even
    * if it drops out of the available options — which happens when deleted encounters are hidden
    * again and the type only occurred on those.
    */
   encounterType?: OpenmrsResourceRef;
-  fromDate?: string;
-  toDate?: string;
 }
 
 /**
@@ -31,30 +30,6 @@ export function distinctEncounterTypes(encounters: Array<AuditEncounter>): Array
   return Array.from(byUuid.values()).sort((a, b) => (a.display ?? '').localeCompare(b.display ?? ''));
 }
 
-function pad(value: number): string {
-  return String(value).padStart(2, '0');
-}
-
-/** The calendar date a `Date` falls on, in the browser's time zone. */
-export function toDateKey(date: Date | null | undefined): string | undefined {
-  if (!date || Number.isNaN(date.getTime())) {
-    return undefined;
-  }
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
-}
-
-/** Local midnight on a calendar date, for handing a stored filter back to the date picker. */
-export function fromDateKey(key: string | undefined): Date | null {
-  if (!key) {
-    return null;
-  }
-  const [year, month, day] = key.split('-').map(Number);
-  if (!year || !month || !day) {
-    return null;
-  }
-  return new Date(year, month - 1, day);
-}
-
 export function hasActiveFilters(filters: EncounterFilters): boolean {
   return Boolean(filters.encounterType || filters.fromDate || filters.toDate);
 }

package/src/audit/patient-record.component.test.tsx

@@ -2,12 +2,12 @@ import React from 'react';
 import { render, screen, waitFor, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { SWRConfig } from 'swr';
-import { openmrsFetch, useConfig } from '@openmrs/esm-framework';
+import { openmrsFetch } from '@openmrs/esm-framework';
 import { type AuditEncounter, type AuditPatient } from '../types';
 import PatientRecord from './patient-record.component';
+import { stubDateRangePicker } from './date-range-picker.test-stub';
 
 const mockOpenmrsFetch = jest.mocked(openmrsFetch);
-const mockUseConfig = jest.mocked(useConfig);
 
 const mockPatient: AuditPatient = {
   uuid: 'patient-1',
@@ -93,9 +93,7 @@ function renderPatientRecord() {
 
 describe('<PatientRecord />', () => {
   beforeEach(() => {
-    mockUseConfig.mockReturnValue({
-      patientChartUrl: '${openmrsSpaBase}/patient/${patientUuid}/chart',
-    });
+    stubDateRangePicker();
     mockRestApi();
   });
 

package/src/audit/patient-record.component.tsx

@@ -2,7 +2,12 @@ import React, { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Button, Checkbox, InlineNotification, Tab, TabList, TabPanel, TabPanels, Tabs } from '@carbon/react';
 import { ArrowLeftIcon, ErrorState } from '@openmrs/esm-framework';
-import { canListDeletedEncounters, getPreferredIdentifier, useAuditPatient } from './audit.resource';
+import {
+  canListDeletedEncounters,
+  getPreferredIdentifier,
+  useAuditPatient,
+  usePatientEncounterTypes,
+} from './audit.resource';
 import { type EncounterFilters } from './encounter-filters';
 import EncounterFiltersBar from './encounter-filters.component';
 import PatientActivity from './patient-activity.component';
@@ -38,6 +43,7 @@ export default function PatientRecord({
   const [filters, setFilters] = useState<EncounterFilters>({});
 
   const { patient, error: patientError, isLoading: isLoadingPatient } = useAuditPatient(patientUuid);
+  const { encounterTypes, isLoading: isLoadingTypes } = usePatientEncounterTypes(patient, includeDeleted);
   const cannotIncludeDeleted = includeDeleted && Boolean(patient) && !canListDeletedEncounters(patient);
 
   return (
@@ -54,7 +60,12 @@ export default function PatientRecord({
         </span>
       </div>
 
-      <EncounterFiltersBar filters={filters} includeDeleted={includeDeleted} onChange={setFilters} patient={patient} />
+      <EncounterFiltersBar
+        encounterTypes={encounterTypes}
+        filters={filters}
+        isLoadingTypes={isLoadingTypes}
+        onChange={setFilters}
+      />
 
       <div className={styles.toolbar}>
         <Checkbox

package/src/audit/patient-search.component.tsx

@@ -42,7 +42,7 @@ export default function PatientSearch({ onSelectPatient }: PatientSearchProps) {
   }, [debouncedSearchTerm]);
 
   return (
-    <div className={styles.section}>
+    <div>
       <Search
         className={styles.searchInput}
         labelText={t('searchForPatient', 'Search for a patient by name or identifier')}

package/src/audit/provider-encounters.component.test.tsx

@@ -0,0 +1,254 @@
+import React from 'react';
+import { render, screen, waitFor, within } 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 } from '../types';
+import ProviderEncounters from './provider-encounters.component';
+import { stubDateRangePicker } from './date-range-picker.test-stub';
+
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+const mockUseConfig = jest.mocked(useConfig);
+
+const provider = {
+  uuid: 'prov-1',
+  display: 'MCPRPG - Louidor Jean paul',
+  identifier: 'MCPRPG',
+  person: { uuid: 'person-1', display: 'Louidor Jean paul' },
+};
+
+/**
+ * What the pihapps audit endpoint answers: whole encounters, paged, including the auditInfo that
+ * names who entered each one. No second read per row, and no FHIR.
+ */
+const encounters: Array<AuditEncounter> = [
+  {
+    uuid: 'enc-1',
+    encounterDatetime: '2026-04-18T09:00:00.000+0000',
+    patient: { uuid: 'patient-1', display: 'Y2AHXV - Dave TestPatient' },
+    encounterType: { uuid: 'type-1', display: 'Oncology Consultation' },
+    form: { uuid: 'form-1', display: 'Oncology Consult Note' },
+    location: { uuid: 'loc-1', display: 'Klinik Ekstèn' },
+    auditInfo: { creator: { uuid: 'user-1', display: 'Cos John' }, dateCreated: '2026-04-18T09:05:00.000+0000' },
+  },
+  {
+    uuid: 'enc-2',
+    voided: true,
+    encounterDatetime: '2026-04-11T08:00:00.000+0000',
+    patient: { uuid: 'patient-2', display: 'Y2BQRS - Jean Baptiste' },
+    encounterType: { uuid: 'type-2', display: 'Inscription' },
+    auditInfo: { creator: { uuid: 'user-2', display: 'data.clerk' }, dateCreated: '2026-04-11T08:02:00.000+0000' },
+  },
+];
+
+const encounterTypeCounts = [
+  { encounterType: { uuid: 'type-2', display: 'Inscription' }, count: 12 },
+  { encounterType: { uuid: 'type-3', display: 'Never Recorded' }, count: 0 },
+  { encounterType: { uuid: 'type-1', display: 'Oncology Consultation' }, count: 30 },
+];
+
+function mockRestApi({ results = encounters } = {}) {
+  mockOpenmrsFetch.mockImplementation((url: string) => {
+    if (url.includes('/pihapps/encounterTypeCount')) {
+      // the endpoint leaves out unused types only when asked, so the mock does too
+      const results = url.includes('onlyUsed=true')
+        ? encounterTypeCounts.filter((entry) => entry.count > 0)
+        : encounterTypeCounts;
+      return Promise.resolve({ data: { results } }) as ReturnType<typeof openmrsFetch>;
+    }
+    if (url.includes('/pihapps/encounter?')) {
+      return Promise.resolve({ data: { results, totalCount: results.length } }) as ReturnType<typeof openmrsFetch>;
+    }
+    return Promise.resolve({ data: provider }) as ReturnType<typeof openmrsFetch>;
+  });
+}
+
+function renderProviderEncounters() {
+  const onSelectEncounter = jest.fn();
+  const onBackToSearch = jest.fn();
+  render(
+    <SWRConfig value={{ dedupingInterval: 0, provider: () => new Map() }}>
+      <ProviderEncounters onBackToSearch={onBackToSearch} onSelectEncounter={onSelectEncounter} providerUuid="prov-1" />
+    </SWRConfig>,
+  );
+  return { onSelectEncounter, onBackToSearch };
+}
+
+describe('<ProviderEncounters />', () => {
+  beforeEach(() => {
+    stubDateRangePicker();
+    mockUseConfig.mockReturnValue({ encountersPageSize: 10 });
+    mockRestApi();
+  });
+
+  /**
+   * The most recent audit search, decoded — `useOpenmrsPagination` rebuilds the url through `URL`.
+   * The most recent one matters because a filter change issues another.
+   */
+  function auditSearchUrl() {
+    const urls = mockOpenmrsFetch.mock.calls
+      .map(([url]) => url as string)
+      .filter((url) => url.includes('/pihapps/encounter?'));
+    return decodeURIComponent(urls[urls.length - 1] ?? '');
+  }
+
+  it('asks the pihapps audit endpoint which encounters name the provider', async () => {
+    renderProviderEncounters();
+
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+    expect(auditSearchUrl()).toContain('/ws/rest/v1/pihapps/encounter?provider=prov-1');
+    expect(auditSearchUrl()).toContain('&limit=10&startIndex=0&totalCount=true');
+  });
+
+  /**
+   * The endpoint leaves voided encounters out unless asked, so an audit has to ask: without this
+   * the table would quietly stop showing what had been deleted.
+   */
+  it('asks for voided encounters to be included', async () => {
+    renderProviderEncounters();
+
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+    expect(auditSearchUrl()).toContain('includeVoided=true');
+  });
+
+  /**
+   * The endpoint sorts nothing unless asked, so a page without an ordering could repeat or skip
+   * rows. A provider search names no audit action, hence the encounter's own datetime.
+   */
+  it('asks for the ordering a provider search wants', async () => {
+    renderProviderEncounters();
+
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+    expect(auditSearchUrl()).toContain('sortBy=encounterDatetime-desc&sortBy=encounterId-desc');
+  });
+
+  /**
+   * One paged request per page: the endpoint returns whole encounters with their auditInfo, so
+   * nothing further is read per row.
+   */
+  it('reads the page in a single request', async () => {
+    renderProviderEncounters();
+
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+    expect(mockOpenmrsFetch.mock.calls.filter(([url]) => (url as string).includes('/pihapps/encounter?'))).toHaveLength(
+      1,
+    );
+    expect(mockOpenmrsFetch.mock.calls.some(([url]) => (url as string).includes('/encounter/'))).toBe(false);
+  });
+
+  it('lists them across patients, naming who entered each one', async () => {
+    renderProviderEncounters();
+
+    // The skeleton renders rows of its own, so wait for real content before reading the table.
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    const firstRow = screen.getAllByRole('row').find((row) => row.textContent?.includes('Dave TestPatient'));
+    expect(firstRow).toHaveTextContent('Oncology Consultation');
+    expect(firstRow).toHaveTextContent('Klinik Ekstèn');
+    expect(firstRow).toHaveTextContent('Cos John');
+
+    const secondRow = screen.getAllByRole('row').find((row) => row.textContent?.includes('Jean Baptiste'));
+    expect(secondRow).toHaveTextContent('data.clerk');
+    expect(secondRow).toHaveTextContent('Deleted');
+  });
+
+  it('is explicit that this is not the same as who changed the record', async () => {
+    renderProviderEncounters();
+
+    expect(await screen.findByText(/not the same as the ones they entered or changed/i)).toBeInTheDocument();
+  });
+
+  it('offers only the encounter types something has been recorded against', async () => {
+    renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    await userEvent.click(screen.getByRole('combobox', { name: /encounter type/i }));
+
+    const options = within(screen.getByRole('listbox')).getAllByRole('option');
+    expect(options.map((option) => option.textContent)).toEqual(['Inscription', 'Oncology Consultation']);
+  });
+
+  it('counts deleted encounters towards their type, as the rest of the audit does', async () => {
+    renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    const countUrls = mockOpenmrsFetch.mock.calls
+      .map(([url]) => String(url))
+      .filter((url) => url.includes('/pihapps/encounterTypeCount'));
+    expect(countUrls.length).toBeGreaterThan(0);
+    expect(countUrls.every((url) => url.includes('includeVoided=true'))).toBe(true);
+    expect(countUrls.every((url) => url.includes('onlyUsed=true'))).toBe(true);
+  });
+
+  it('narrows the search on the server by encounter type', async () => {
+    renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    await userEvent.click(screen.getByRole('combobox', { name: /encounter type/i }));
+    await userEvent.click(await screen.findByRole('option', { name: 'Inscription' }));
+
+    await waitFor(() => expect(auditSearchUrl()).toContain('&encounterType=type-2'));
+    // the page goes back to the start, since a different filter is a different set of pages
+    expect(auditSearchUrl()).toContain('&startIndex=0');
+  });
+
+  it('narrows the search on the server by encounter date', async () => {
+    renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    // the stubbed range picker reads its input as MM/DD/YYYY, hence the American-looking dates
+    await userEvent.clear(screen.getByLabelText('Encounter date range'));
+    await userEvent.type(screen.getByLabelText('Encounter date range'), '04/01/2026–04/30/2026');
+
+    await waitFor(() =>
+      expect(auditSearchUrl()).toContain(
+        'encounterDatetimeOnOrAfter=2026-04-01&encounterDatetimeOnOrBefore=2026-04-30',
+      ),
+    );
+  });
+
+  it('keeps the search unbounded while only the start of a range has been typed', async () => {
+    renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    await userEvent.type(screen.getByLabelText('Encounter date range'), '04/01/2026–');
+
+    expect(screen.getByRole('cell', { name: 'Oncology Consultation' })).toBeInTheDocument();
+    expect(auditSearchUrl()).not.toContain('encounterDatetimeOnOrAfter');
+  });
+
+  it('says so when nothing matches the filters', async () => {
+    renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    mockRestApi({ results: [] });
+    await userEvent.click(screen.getByRole('combobox', { name: /encounter type/i }));
+    await userEvent.click(await screen.findByRole('option', { name: 'Inscription' }));
+
+    expect(await screen.findByText(/no encounters for this provider match these filters/i)).toBeInTheDocument();
+  });
+
+  it('drills down into the encounter that is clicked', async () => {
+    const { onSelectEncounter } = renderProviderEncounters();
+    await screen.findByRole('cell', { name: 'Oncology Consultation' });
+
+    await userEvent.click(screen.getAllByRole('button', { name: /2026/ })[0]);
+
+    expect(onSelectEncounter).toHaveBeenCalledWith('enc-1');
+  });
+
+  it('goes back to the provider search', async () => {
+    const { onBackToSearch } = renderProviderEncounters();
+
+    await userEvent.click(screen.getByRole('button', { name: /back to provider search/i }));
+
+    expect(onBackToSearch).toHaveBeenCalled();
+  });
+
+  it('says so when the provider is on no encounters', async () => {
+    mockRestApi({ results: [] });
+    renderProviderEncounters();
+
+    expect(await screen.findByText(/not recorded on any encounters/i)).toBeInTheDocument();
+  });
+});