@openmrs/esm-patient-tests-app 11.3.1-pre.9435 → 11.3.1-pre.9437

package/src/test-results/grouped-timeline/useObstreeData.test.ts

@@ -0,0 +1,471 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { openmrsFetch } from '@openmrs/esm-framework';
+import { useGetManyObstreeData, useGetObstreeData, type ObsTreeNode } from './useObstreeData';
+
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+
+describe('useObstreeData', () => {
+  describe('augmentObstreeData via useGetObstreeData', () => {
+    it('should add flatName to nodes', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Hemoglobin',
+          conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+          hasData: false,
+          subSets: [],
+          obs: [
+            {
+              value: '12.5',
+              obsDatetime: '2024-01-01',
+              interpretation: 'NORMAL',
+            },
+          ],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'hemoglobin-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.flatName).toBe('Hemoglobin');
+      expect(data.hasData).toBe(true);
+    });
+
+    it('should build hierarchical flatName for nested nodes', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Complete Blood Count',
+          conceptUuid: 'cbc-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Hemoglobin',
+              conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+              hasData: false,
+              subSets: [],
+              obs: [
+                {
+                  value: '12.5',
+                  obsDatetime: '2024-01-01',
+                },
+              ],
+            },
+          ],
+          obs: [],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'cbc-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.flatName).toBe('Complete Blood Count');
+      expect(data.subSets[0].flatName).toBe('Complete Blood Count-Hemoglobin');
+    });
+
+    it('should handle Bloodwork prefix specially to avoid long names', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Bloodwork',
+          conceptUuid: 'bloodwork-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Hemoglobin',
+              conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+              hasData: false,
+              subSets: [],
+              obs: [{ value: '12.5', obsDatetime: '2024-01-01' }],
+            },
+          ],
+          obs: [],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'bloodwork-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.flatName).toBe('Bloodwork');
+      // Bloodwork children should use simplified names
+      expect(data.subSets[0].flatName).toBe('Hemoglobin');
+    });
+
+    it('should set hasData to true when node has observations', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Hemoglobin',
+          conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+          hasData: false,
+          subSets: [],
+          obs: [
+            {
+              value: '12.5',
+              obsDatetime: '2024-01-01',
+            },
+          ],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'hemoglobin-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.hasData).toBe(true);
+    });
+
+    it('should propagate hasData to parent when child has data', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Complete Blood Count',
+          conceptUuid: 'cbc-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Hemoglobin',
+              conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+              hasData: false,
+              subSets: [],
+              obs: [{ value: '12.5', obsDatetime: '2024-01-01' }],
+            },
+          ],
+          obs: [],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'cbc-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.hasData).toBe(true);
+      expect(data.subSets[0].hasData).toBe(true);
+    });
+
+    it('should add interpretation to observations without one', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Hemoglobin',
+          conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+          lowNormal: 10.4,
+          hiNormal: 17.8,
+          units: 'g/dL',
+          hasData: false,
+          subSets: [],
+          obs: [
+            {
+              value: '5.0', // Below normal
+              obsDatetime: '2024-01-01',
+            },
+          ],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'hemoglobin-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      // Interpretation is added by assessValue helper
+      const data = result.current.data as ObsTreeNode;
+      expect(data.obs[0].interpretation).toBeDefined();
+    });
+
+    it('should preserve existing interpretation if present', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Hemoglobin',
+          conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+          lowNormal: 10.4,
+          hiNormal: 17.8,
+          units: 'g/dL',
+          hasData: false,
+          subSets: [],
+          obs: [
+            {
+              value: '12.5',
+              obsDatetime: '2024-01-01',
+              interpretation: 'NORMAL',
+            },
+          ],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'hemoglobin-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.obs[0].interpretation).toBe('NORMAL');
+    });
+
+    it('should use observation-level reference ranges when available', async () => {
+      const mockResponse = {
+        data: {
+          display: 'Hemoglobin',
+          conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+          lowNormal: 10.4,
+          hiNormal: 17.8,
+          units: 'g/dL',
+          hasData: false,
+          subSets: [],
+          obs: [
+            {
+              value: '12.5',
+              obsDatetime: '2024-01-01',
+              // Observation-specific reference ranges (criteria-based)
+              lowNormal: 12.0,
+              hiNormal: 16.0,
+            },
+          ],
+        },
+      };
+
+      mockOpenmrsFetch.mockResolvedValue(mockResponse as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'hemoglobin-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      // Observation should have a range property (formatted by helper)
+      const data = result.current.data as ObsTreeNode;
+      expect(data.obs[0]).toHaveProperty('range');
+      expect((data.obs[0] as any).range).toBeDefined();
+    });
+  });
+
+  describe('filterTreesWithData via useGetManyObstreeData', () => {
+    it('should filter out leaf nodes without data', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Complete Blood Count',
+          conceptUuid: 'cbc-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Hemoglobin',
+              conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+              hasData: false,
+              subSets: [],
+              obs: [{ value: '12.5', obsDatetime: '2024-01-01' }],
+            },
+            {
+              display: 'Platelets',
+              conceptUuid: 'platelets-uuid',
+              hasData: false,
+              subSets: [],
+              obs: [], // No data
+            },
+          ],
+          obs: [],
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetManyObstreeData('patient-uuid', ['cbc-uuid']));
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.roots).toHaveLength(1);
+      expect(result.current.roots[0].subSets).toHaveLength(1);
+      expect(result.current.roots[0].subSets[0].display).toBe('Hemoglobin');
+    });
+
+    it('should keep parent nodes even if they have no direct observations', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Hematology',
+          conceptUuid: 'hematology-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Complete Blood Count',
+              conceptUuid: 'cbc-uuid',
+              hasData: false,
+              subSets: [
+                {
+                  display: 'Hemoglobin',
+                  conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                  hasData: false,
+                  subSets: [],
+                  obs: [{ value: '12.5', obsDatetime: '2024-01-01' }],
+                },
+              ],
+              obs: [],
+            },
+          ],
+          obs: [],
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetManyObstreeData('patient-uuid', ['hematology-uuid']));
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.roots).toHaveLength(1);
+      expect(result.current.roots[0].display).toBe('Hematology');
+      expect(result.current.roots[0].subSets).toHaveLength(1);
+      expect(result.current.roots[0].subSets[0].display).toBe('Complete Blood Count');
+    });
+
+    it('should keep parent nodes even when all leaf nodes have no data', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Complete Blood Count',
+          conceptUuid: 'cbc-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Hemoglobin',
+              conceptUuid: '21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+              hasData: false,
+              subSets: [],
+              obs: [], // No data
+            },
+            {
+              display: 'Hematocrit',
+              conceptUuid: 'hematocrit-uuid',
+              hasData: false,
+              subSets: [],
+              obs: [], // No data
+            },
+          ],
+          obs: [],
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetManyObstreeData('patient-uuid', ['cbc-uuid']));
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      // Parent node is kept with filtered subSets
+      expect(result.current.roots).toHaveLength(1);
+      expect(result.current.roots[0].display).toBe('Complete Blood Count');
+    });
+
+    it('should handle nodes that are both parent and have observations', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Test Node',
+          conceptUuid: 'test-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Child Test',
+              conceptUuid: 'child-uuid',
+              hasData: false,
+              subSets: [],
+              obs: [{ value: '100', obsDatetime: '2024-01-01' }],
+            },
+          ],
+          obs: [{ value: '50', obsDatetime: '2024-01-01' }], // Parent also has obs
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetManyObstreeData('patient-uuid', ['test-uuid']));
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.roots).toHaveLength(1);
+      expect(result.current.roots[0].hasData).toBe(true);
+      expect(result.current.roots[0].obs).toHaveLength(1);
+      expect(result.current.roots[0].subSets).toHaveLength(1);
+    });
+  });
+
+  describe('useGetManyObstreeData', () => {
+    it('should tag root nodes with requested conceptUuid', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Hemoglobin',
+          hasData: false,
+          subSets: [],
+          obs: [{ value: '12.5', obsDatetime: '2024-01-01' }],
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetManyObstreeData('patient-uuid', ['hemoglobin-uuid']));
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.roots[0].conceptUuid).toBe('hemoglobin-uuid');
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle nodes without subSets or obs', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Empty Node',
+          conceptUuid: 'empty-uuid',
+          hasData: false,
+          subSets: [],
+          obs: [],
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'empty-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.flatName).toBe('Empty Node');
+      // hasData may be set to false or true depending on augmentation logic
+      expect(data).toHaveProperty('hasData');
+    });
+
+    it('should handle deeply nested structures', async () => {
+      mockOpenmrsFetch.mockResolvedValue({
+        data: {
+          display: 'Level1',
+          conceptUuid: 'level1-uuid',
+          hasData: false,
+          subSets: [
+            {
+              display: 'Level2',
+              conceptUuid: 'level2-uuid',
+              hasData: false,
+              subSets: [
+                {
+                  display: 'Level3',
+                  conceptUuid: 'level3-uuid',
+                  hasData: false,
+                  subSets: [],
+                  obs: [{ value: '100', obsDatetime: '2024-01-01' }],
+                },
+              ],
+              obs: [],
+            },
+          ],
+          obs: [],
+        },
+      } as any);
+
+      const { result } = renderHook(() => useGetObstreeData('patient-uuid', 'level1-uuid'));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      const data = result.current.data as ObsTreeNode;
+      expect(data.flatName).toBe('Level1');
+      expect(data.subSets[0].flatName).toBe('Level1-Level2');
+      expect(data.subSets[0].subSets[0].flatName).toBe('Level1-Level2-Level3');
+      expect(data.hasData).toBe(true);
+    });
+  });
+});

package/src/test-results/individual-results-table-tablet/usePanelData.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo } from 'react';
-import { type FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
 import useSWRInfinite from 'swr/infinite';
+import { type FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
 import { extractMetaInformation, getConceptUuid } from './helper';
 import {
   type Concept,
@@ -159,32 +159,46 @@ export default function usePanelData(patientUuid: string) {
     [observations],
   );
 
-  const setObservations: Array<ObsRecord> = useMemo(
-    () =>
-      observations
-        ? observations
-            .filter((obs) => !!obs.hasMember)
-            .map((obs) => {
-              const relatedObs = [];
-              obs.hasMember.forEach((memb) => {
-                const membUuid = memb.reference.split('/')[1];
-                const memberObservationIndex = individualObservations.findIndex((obs) => obs.id === membUuid);
-                if (memberObservationIndex > -1) {
-                  relatedObs.push(individualObservations[memberObservationIndex]);
-                  individualObservations.splice(memberObservationIndex, 1);
-                }
-              });
-              return {
-                ...obs,
-                relatedObs,
-              };
-            })
-        : [],
-    [individualObservations, observations],
-  );
+  const setObservations: Array<ObsRecord> = useMemo(() => {
+    if (!observations) {
+      return [];
+    }
+
+    // Create a map of individual observations for efficient lookup
+    const individualObsMap = new Map(individualObservations.map((obs) => [obs.id, obs]));
+    const usedIndividualObsIds = new Set<string>();
+
+    return observations
+      .filter((obs) => !!obs.hasMember)
+      .map((obs) => {
+        const relatedObs: Array<ObsRecord> = [];
+        obs.hasMember.forEach((memb) => {
+          const membUuid = memb.reference.split('/')[1];
+          const memberObs = individualObsMap.get(membUuid);
+          if (memberObs && !usedIndividualObsIds.has(membUuid)) {
+            relatedObs.push(memberObs);
+            usedIndividualObsIds.add(membUuid);
+          }
+        });
+        return {
+          ...obs,
+          relatedObs,
+        };
+      });
+  }, [individualObservations, observations]);
+
+  const remainingIndividualObservations = useMemo(() => {
+    const usedIds = new Set<string>();
+    setObservations.forEach((setObs) => {
+      setObs.relatedObs.forEach((relatedObs) => {
+        usedIds.add(relatedObs.id);
+      });
+    });
+    return individualObservations.filter((obs) => !usedIds.has(obs.id));
+  }, [individualObservations, setObservations]);
 
   const panels = useMemo(() => {
-    const allPanels = [...individualObservations, ...setObservations].sort(
+    const allPanels = [...remainingIndividualObservations, ...setObservations].sort(
       (obs1, obs2) => Date.parse(obs2.effectiveDateTime) - Date.parse(obs1.effectiveDateTime),
     );
     const usedConcepts: Set<string> = new Set();
@@ -195,7 +209,7 @@ export default function usePanelData(patientUuid: string) {
       latestPanels.push(panel);
     });
     return latestPanels;
-  }, [individualObservations, setObservations]);
+  }, [remainingIndividualObservations, setObservations]);
 
   const panelsData = useMemo(
     () => ({

package/src/test-results/loadPatientTestData/helpers.ts

@@ -39,7 +39,7 @@ export function addUserDataToCache(patientUuid: string, data: PatientData, indic
   }
 }
 
-async function getLatestObsUuid(patientUuid: string): Promise<string> {
+async function getLatestObsUuid(patientUuid: string): Promise<string | undefined> {
   const request = fhirObservationRequests({
     patient: patientUuid,
     category: 'laboratory',
@@ -61,12 +61,13 @@ async function getLatestObsUuid(patientUuid: string): Promise<string> {
  * @param { string } indicator UUID of the newest observation
  */
 export function getUserDataFromCache(patientUuid: string): [PatientData | undefined, Promise<boolean>] {
-  const [data] = patientResultsDataCache[patientUuid] || [];
+  const cacheEntry = patientResultsDataCache[patientUuid];
+  const [data, , indicator] = cacheEntry || [];
 
   return [
     data,
-    !!data
-      ? getLatestObsUuid(patientUuid).then((obsUuid) => obsUuid !== patientResultsDataCache?.[patientUuid]?.[2])
+    !!data && indicator
+      ? getLatestObsUuid(patientUuid).then((obsUuid) => obsUuid !== indicator)
       : Promise.resolve(true),
   ];
 }
@@ -109,31 +110,47 @@ export const loadObsEntries = async (patientUuid: string): Promise<Array<ObsReco
 
   let responses = await Promise.all(retrieveFromIterator(requests, CHUNK_PREFETCH_COUNT));
 
-  const total = responses[0].total;
+  const total = responses[0]?.total ?? 0;
 
   if (total > CHUNK_PREFETCH_COUNT * PAGE_SIZE) {
     const missingRequestsCount = Math.ceil(total / PAGE_SIZE) - CHUNK_PREFETCH_COUNT;
     responses = [...responses, ...(await Promise.all(retrieveFromIterator(requests, missingRequestsCount)))];
   }
 
-  return responses.slice(0, Math.ceil(total / PAGE_SIZE)).flatMap((res) => res.entry.map((e) => e.resource));
+  return responses.slice(0, Math.ceil(total / PAGE_SIZE)).flatMap((res) => res?.entry?.map((e) => e.resource) ?? []);
 };
 
-export const getEntryConceptClassUuid = (entry) => entry.code.coding[0].code;
+export const getEntryConceptClassUuid = (entry: ObsRecord | FHIRObservationResource): string =>
+  entry?.code?.coding?.[0]?.code ?? '';
 
 const conceptCache: Record<ConceptUuid, Promise<ConceptRecord>> = {};
 /**
  * fetch all concepts for all given observation entries
  */
 export function loadPresentConcepts(entries: Array<ObsRecord>): Promise<Array<ConceptRecord>> {
-  return Promise.all(
-    [...new Set(entries.map(getEntryConceptClassUuid))].map(
+  const conceptUuids = [...new Set(entries.map(getEntryConceptClassUuid).filter(Boolean))];
+
+  return Promise.allSettled(
+    conceptUuids.map(
       (conceptUuid) =>
         conceptCache[conceptUuid] ||
-        (conceptCache[conceptUuid] = fetch(`${window.openmrsBase}${restBaseUrl}/concept/${conceptUuid}?v=full`).then(
-          (res) => res.json(),
-        )),
+        (conceptCache[conceptUuid] = fetch(`${window.openmrsBase}${restBaseUrl}/concept/${conceptUuid}?v=full`)
+          .then((res) => {
+            if (!res.ok) {
+              throw new Error(`Failed to fetch concept ${conceptUuid}: ${res.statusText}`);
+            }
+            return res.json();
+          })
+          .catch((error) => {
+            // Remove failed promise from cache so it can be retried
+            delete conceptCache[conceptUuid];
+            throw error;
+          })),
     ),
+  ).then((results) =>
+    results
+      .filter((result): result is PromiseFulfilledResult<ConceptRecord> => result.status === 'fulfilled')
+      .map((result) => result.value),
   );
 }
 

package/src/test-results/loadPatientTestData/usePatientResultsData.ts

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from 'react';
+import { useEffect, useState, useRef } from 'react';
 import { type PatientData } from '@openmrs/esm-patient-common-lib';
 import loadPatientData from './loadPatientData';
 
@@ -14,18 +14,29 @@ const usePatientResultsData = (patientUuid: string): LoadingState => {
     loaded: false,
     error: undefined,
   });
+  const isMountedRef = useRef(true);
 
   useEffect(() => {
-    let unmounted = false;
+    isMountedRef.current = true;
     if (patientUuid) {
       const [data, reloadedDataPromise] = loadPatientData(patientUuid);
-      if (!!data) setState({ sortedObs: data, loaded: true, error: undefined });
-      reloadedDataPromise.then((reloadedData) => {
-        if (reloadedData !== data && !unmounted) setState({ sortedObs: reloadedData, loaded: true, error: undefined });
-      });
+      if (!!data && isMountedRef.current) {
+        setState({ sortedObs: data, loaded: true, error: undefined });
+      }
+      reloadedDataPromise
+        .then((reloadedData) => {
+          if (reloadedData !== data && isMountedRef.current) {
+            setState({ sortedObs: reloadedData, loaded: true, error: undefined });
+          }
+        })
+        .catch((error) => {
+          if (isMountedRef.current) {
+            setState({ sortedObs: {}, loaded: true, error });
+          }
+        });
     }
     return () => {
-      unmounted = true;
+      isMountedRef.current = false;
     };
   }, [patientUuid]);