vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/utils/intake-utils.test.ts

@@ -0,0 +1,1137 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type {
+  Coding,
+  Patient,
+  Questionnaire,
+  QuestionnaireResponse,
+  QuestionnaireResponseItemAnswer,
+  Reference,
+  Organization,
+} from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import {
+  addAllergy,
+  addCondition,
+  addConsent,
+  addCoverage,
+  addExtension,
+  addFamilyMemberHistory,
+  addImmunization,
+  addLanguage,
+  addMedication,
+  addPharmacy,
+  convertDateToDateTime,
+  findQuestionnaireItem,
+  getGroupRepeatedAnswers,
+  getHumanName,
+  getPatientAddress,
+  observationCategoryMapping,
+  observationCodeMapping,
+  upsertObservation,
+} from './intake-utils';
+
+describe('intake utils', () => {
+  let medplum: MockClient;
+  let patient: Patient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    patient = { resourceType: 'Patient', id: 'patient-1' };
+  });
+
+  describe('addExtension', () => {
+    test('adds coded extension with sub extension text', () => {
+      const answer: QuestionnaireResponseItemAnswer = {
+        valueCoding: { system: 'http://example.com', code: 'code', display: 'Display' },
+      };
+
+      addExtension(patient, 'http://example.com/ext', 'valueCoding', answer, 'ombCategory');
+
+      expect(patient.extension).toEqual([
+        {
+          url: 'http://example.com/ext',
+          extension: [
+            {
+              url: 'ombCategory',
+              valueCoding: { system: 'http://example.com', code: 'code', display: 'Display' },
+            },
+            {
+              url: 'text',
+              valueString: 'Display',
+            },
+          ],
+        },
+      ]);
+    });
+
+    test('adds boolean extension and interprets undefined as false', () => {
+      addExtension(patient, 'http://example.com/bool', 'valueBoolean', {});
+
+      expect(patient.extension).toEqual([
+        expect.objectContaining({
+          url: 'http://example.com/bool',
+          valueBoolean: false,
+        }),
+      ]);
+    });
+
+    test('adds extension without sub extension', () => {
+      const answer: QuestionnaireResponseItemAnswer = {
+        valueCoding: { system: 'http://example.com', code: 'code' },
+      };
+
+      addExtension(patient, 'http://example.com/ext', 'valueCoding', answer);
+
+      expect(patient.extension).toEqual([
+        {
+          url: 'http://example.com/ext',
+          valueCoding: { system: 'http://example.com', code: 'code' },
+        },
+      ]);
+    });
+
+    test('adds extension with sub extension but no display text when display is missing', () => {
+      const answer: QuestionnaireResponseItemAnswer = {
+        valueCoding: { system: 'http://example.com', code: 'code' },
+      };
+
+      addExtension(patient, 'http://example.com/ext', 'valueCoding', answer, 'ombCategory');
+
+      expect(patient.extension).toEqual([
+        {
+          url: 'http://example.com/ext',
+          extension: [
+            {
+              url: 'ombCategory',
+              valueCoding: { system: 'http://example.com', code: 'code' },
+            },
+          ],
+        },
+      ]);
+    });
+
+    test('returns early when value is undefined', () => {
+      const initialExtensions = patient.extension;
+      addExtension(patient, 'http://example.com/ext', 'valueCoding', undefined);
+      expect(patient.extension).toBe(initialExtensions);
+    });
+
+    test('adds boolean extension with true value', () => {
+      addExtension(patient, 'http://example.com/bool', 'valueBoolean', { valueBoolean: true });
+      expect(patient.extension).toEqual([
+        expect.objectContaining({
+          url: 'http://example.com/bool',
+          valueBoolean: true,
+        }),
+      ]);
+    });
+  });
+
+  describe('addLanguage', () => {
+    test('adds and updates preferred language', () => {
+      const coding: Coding = { system: 'urn:ietf:bcp:47', code: 'en', display: 'English' };
+
+      addLanguage(patient, coding);
+      addLanguage(patient, coding, true);
+
+      expect(patient.communication).toHaveLength(1);
+      expect(patient.communication?.[0].preferred).toBe(true);
+    });
+
+    test('returns early when coding is undefined', () => {
+      const initialCommunication = patient.communication;
+      addLanguage(patient, undefined);
+      expect(patient.communication).toBe(initialCommunication);
+    });
+
+    test('adds new language when not present', () => {
+      const coding: Coding = { system: 'urn:ietf:bcp:47', code: 'es', display: 'Spanish' };
+      addLanguage(patient, coding);
+      expect(patient.communication).toHaveLength(1);
+      expect(patient.communication?.[0].language.coding?.[0].code).toBe('es');
+    });
+
+    test('sets preferred flag on existing language', () => {
+      const coding: Coding = { system: 'urn:ietf:bcp:47', code: 'en', display: 'English' };
+      patient.communication = [
+        {
+          language: {
+            coding: [{ system: 'urn:ietf:bcp:47', code: 'en', display: 'English' }],
+          },
+        },
+      ];
+      addLanguage(patient, coding, true);
+      expect(patient.communication?.[0].preferred).toBe(true);
+    });
+  });
+
+  describe('questionnaire helpers', () => {
+    test('getHumanName builds full name', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'first-name': { valueString: 'Ada' },
+        'middle-name': { valueString: 'M.' },
+        'last-name': { valueString: 'Lovelace' },
+      };
+      expect(getHumanName(answers)).toEqual({ given: ['Ada', 'M.'], family: 'Lovelace' });
+    });
+
+    test('getHumanName builds name with prefix', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'related-person-first-name': { valueString: 'John' },
+        'related-person-last-name': { valueString: 'Doe' },
+      };
+      expect(getHumanName(answers, 'related-person-')).toEqual({ given: ['John'], family: 'Doe' });
+    });
+
+    test('getHumanName returns undefined when no name fields present', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {};
+      expect(getHumanName(answers)).toBeUndefined();
+    });
+
+    test('getHumanName builds name with only first name', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'first-name': { valueString: 'Ada' },
+      };
+      expect(getHumanName(answers)).toEqual({ given: ['Ada'] });
+    });
+
+    test('getHumanName builds name with only last name', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'last-name': { valueString: 'Lovelace' },
+      };
+      expect(getHumanName(answers)).toEqual({ family: 'Lovelace' });
+    });
+
+    test('getPatientAddress builds address', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        street: { valueString: '1 Main St' },
+        city: { valueString: 'Springfield' },
+        state: { valueCoding: { code: 'CA' } },
+        zip: { valueString: '12345' },
+      };
+      expect(getPatientAddress(answers)).toEqual(
+        expect.objectContaining({ city: 'Springfield', state: 'CA', postalCode: '12345', use: 'home' })
+      );
+    });
+
+    test('getPatientAddress returns undefined when no address fields present', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {};
+      expect(getPatientAddress(answers)).toBeUndefined();
+    });
+
+    test('getPatientAddress builds partial address', () => {
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        city: { valueString: 'Springfield' },
+      };
+      expect(getPatientAddress(answers)).toEqual(
+        expect.objectContaining({ city: 'Springfield', use: 'home', type: 'physical' })
+      );
+    });
+
+    test('findQuestionnaireItem finds nested item', () => {
+      const questionnaire: Questionnaire = {
+        resourceType: 'Questionnaire',
+        item: [
+          {
+            linkId: 'group',
+            type: 'group',
+            item: [{ linkId: 'nested', type: 'string' }],
+          },
+        ],
+        status: 'active',
+      };
+      const result = findQuestionnaireItem(questionnaire.item, 'nested');
+      expect(result?.linkId).toBe('nested');
+    });
+
+    test('getGroupRepeatedAnswers flattens repeating groups', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [{ linkId: 'allergies', type: 'group', item: [{ linkId: 'allergy-substance', type: 'string' }] }],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [
+          {
+            linkId: 'allergies',
+            item: [{ linkId: 'allergy-substance', answer: [{ valueString: 'Peanuts' }] }],
+          },
+          {
+            linkId: 'allergies',
+            item: [{ linkId: 'allergy-substance', answer: [{ valueString: 'Shellfish' }] }],
+          },
+        ],
+      };
+
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'allergies');
+      expect(answers).toEqual([
+        { 'allergy-substance': { valueString: 'Peanuts' } },
+        { 'allergy-substance': { valueString: 'Shellfish' } },
+      ]);
+    });
+
+    test('getGroupRepeatedAnswers returns empty array when no response groups found', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [{ linkId: 'allergies', type: 'group', item: [{ linkId: 'allergy-substance', type: 'string' }] }],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [],
+      };
+
+      // When no response items match the groupLinkId, returns empty array
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'allergies');
+      expect(answers).toEqual([]);
+    });
+
+    test('getGroupRepeatedAnswers returns empty array when questionnaire item is not a group', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [{ linkId: 'allergies', type: 'string' }],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [{ linkId: 'allergies' }],
+      };
+
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'allergies');
+      expect(answers).toEqual([]);
+    });
+
+    test('getGroupRepeatedAnswers handles nested subgroups', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [
+          {
+            linkId: 'group',
+            type: 'group',
+            item: [
+              { linkId: 'field1', type: 'string' },
+              {
+                linkId: 'subgroup',
+                type: 'group',
+                item: [{ linkId: 'subfield1', type: 'string' }],
+              },
+            ],
+          },
+        ],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [
+          {
+            linkId: 'group',
+            item: [
+              { linkId: 'field1', answer: [{ valueString: 'value1' }] },
+              {
+                linkId: 'subgroup',
+                item: [{ linkId: 'subfield1', answer: [{ valueString: 'subvalue1' }] }],
+              },
+            ],
+          },
+        ],
+      };
+
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'group');
+      expect(answers).toEqual([
+        {
+          field1: { valueString: 'value1' },
+          subgroup: { subfield1: { valueString: 'subvalue1' } },
+        },
+      ]);
+    });
+
+    test('findQuestionnaireItem returns undefined when item not found', () => {
+      const questionnaire: Questionnaire = {
+        resourceType: 'Questionnaire',
+        item: [{ linkId: 'other', type: 'string' }],
+        status: 'active',
+      };
+      const result = findQuestionnaireItem(questionnaire.item, 'not-found');
+      expect(result).toBeUndefined();
+    });
+
+    test('findQuestionnaireItem returns undefined when items is undefined', () => {
+      const result = findQuestionnaireItem(undefined, 'any');
+      expect(result).toBeUndefined();
+    });
+
+    test('findQuestionnaireItem handles undefined currentItem in reduce', () => {
+      const questionnaire: Questionnaire = {
+        resourceType: 'Questionnaire',
+        item: [undefined as any, { linkId: 'found', type: 'string' }],
+        status: 'active',
+      };
+      const result = findQuestionnaireItem(questionnaire.item, 'found');
+      expect(result?.linkId).toBe('found');
+    });
+  });
+
+  describe('convertDateToDateTime', () => {
+    test('converts date to ISO string', () => {
+      expect(convertDateToDateTime('2020-01-01')).toContain('2020-01-01T00:00:00');
+      expect(convertDateToDateTime(undefined)).toBeUndefined();
+    });
+  });
+
+  describe('upsertObservation', () => {
+    test('upserts codeable concept observation', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await upsertObservation(
+        medplum as any,
+        patient,
+        observationCodeMapping.smokingStatus,
+        observationCategoryMapping.socialHistory,
+        'valueCodeableConcept',
+        { valueCoding: { system: 'http://example.com', code: 'never' } }
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('skips when no value provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      await upsertObservation(
+        medplum as any,
+        patient,
+        observationCodeMapping.smokingStatus,
+        observationCategoryMapping.socialHistory,
+        'valueCodeableConcept',
+        undefined
+      );
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('skips when no code provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      // The function checks for !value || !code early, but if code is provided without coding,
+      // it will try to access coding[0] which causes an error
+      // So we test with undefined code to trigger the early return
+      await upsertObservation(
+        medplum as any,
+        patient,
+        undefined as any,
+        observationCategoryMapping.socialHistory,
+        'valueCodeableConcept',
+        { valueCoding: { system: 'http://example.com', code: 'never' } }
+      );
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('upserts dateTime observation', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await upsertObservation(
+        medplum as any,
+        patient,
+        observationCodeMapping.estimatedDeliveryDate,
+        observationCategoryMapping.socialHistory,
+        'valueDateTime',
+        { valueDateTime: '2024-12-31T00:00:00Z' }
+      );
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          valueDateTime: '2024-12-31T00:00:00Z',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('adds profile URL when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await upsertObservation(
+        medplum as any,
+        patient,
+        observationCodeMapping.smokingStatus,
+        observationCategoryMapping.socialHistory,
+        'valueCodeableConcept',
+        { valueCoding: { system: 'http://example.com', code: 'never' } },
+        'http://example.com/profile'
+      );
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta: expect.objectContaining({
+            profile: ['http://example.com/profile'],
+          }),
+        }),
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('resource helpers', () => {
+    test('addAllergy returns early without substance', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      await addAllergy(medplum as any, patient, {});
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('addAllergy upserts when code present', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addAllergy(medplum as any, patient, {
+        'allergy-substance': { valueCoding: { system: 'http://example.com', code: 'peanut' } },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'AllergyIntolerance',
+        }),
+        expect.objectContaining({
+          patient: `Patient/${patient.id}`,
+        })
+      );
+    });
+
+    test('addAllergy includes reaction when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addAllergy(medplum as any, patient, {
+        'allergy-substance': { valueCoding: { system: 'http://example.com', code: 'peanut' } },
+        'allergy-reaction': { valueString: 'Hives' },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          reaction: [{ manifestation: [{ text: 'Hives' }] }],
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addAllergy includes onsetDateTime when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addAllergy(medplum as any, patient, {
+        'allergy-substance': { valueCoding: { system: 'http://example.com', code: 'peanut' } },
+        'allergy-onset': { valueDateTime: '2020-01-01T00:00:00Z' },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onsetDateTime: '2020-01-01T00:00:00Z',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addCoverage upserts coverage resource', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'self' } },
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'Coverage',
+          beneficiary: expect.objectContaining({ reference: `Patient/${patient.id}` }),
+        }),
+        expect.objectContaining({
+          beneficiary: `Patient/${patient.id}`,
+        })
+      );
+    });
+
+    test('addConsent creates resource with provided scope', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      await addConsent(
+        medplum as any,
+        patient,
+        true,
+        observationCategoryMapping.socialHistory,
+        observationCategoryMapping.sdoh,
+        undefined,
+        '2020-01-01'
+      );
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'Consent',
+          patient: expect.objectContaining({ reference: `Patient/${patient.id}` }),
+          status: 'active',
+          dateTime: '2020-01-01',
+        })
+      );
+    });
+
+    test('addConsent creates resource with rejected status when consentGiven is false', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      await addConsent(
+        medplum as any,
+        patient,
+        false,
+        observationCategoryMapping.socialHistory,
+        observationCategoryMapping.sdoh,
+        undefined,
+        '2020-01-01'
+      );
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 'rejected',
+        })
+      );
+    });
+
+    test('addConsent includes policyRule when provided', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const policyRule = { coding: [{ code: 'hipaa-npp' }] };
+      await addConsent(
+        medplum as any,
+        patient,
+        true,
+        observationCategoryMapping.socialHistory,
+        observationCategoryMapping.sdoh,
+        policyRule,
+        '2020-01-01'
+      );
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          policyRule: policyRule,
+        })
+      );
+    });
+
+    test('addMedication returns early without code', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      await addMedication(medplum as any, patient, {});
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('addMedication upserts when code present', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addMedication(medplum as any, patient, {
+        'medication-code': { valueCoding: { system: 'http://example.com', code: 'aspirin' } },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'MedicationRequest',
+          status: 'active',
+          intent: 'order',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addMedication includes note when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addMedication(medplum as any, patient, {
+        'medication-code': { valueCoding: { system: 'http://example.com', code: 'aspirin' } },
+        'medication-note': { valueString: 'Take with food' },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          note: [{ text: 'Take with food' }],
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addCondition returns early without code', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      await addCondition(medplum as any, patient, {});
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('addCondition upserts when code present', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addCondition(medplum as any, patient, {
+        'medical-history-problem': { valueCoding: { system: 'http://example.com', code: 'diabetes' } },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'Condition',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addCondition includes clinicalStatus when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addCondition(medplum as any, patient, {
+        'medical-history-problem': { valueCoding: { system: 'http://example.com', code: 'diabetes' } },
+        'medical-history-clinical-status': { valueCoding: { system: 'http://example.com', code: 'active' } },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          clinicalStatus: { coding: [{ system: 'http://example.com', code: 'active' }] },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addCondition includes onsetDateTime when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addCondition(medplum as any, patient, {
+        'medical-history-problem': { valueCoding: { system: 'http://example.com', code: 'diabetes' } },
+        'medical-history-onset': { valueDateTime: '2020-01-01T00:00:00Z' },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onsetDateTime: '2020-01-01T00:00:00Z',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addFamilyMemberHistory returns early without condition or relationship', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      await addFamilyMemberHistory(medplum as any, patient, {
+        'family-member-history-problem': { valueCoding: { system: 'http://example.com', code: 'diabetes' } },
+      });
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('addFamilyMemberHistory upserts when condition and relationship present', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addFamilyMemberHistory(medplum as any, patient, {
+        'family-member-history-problem': { valueCoding: { system: 'http://example.com', code: 'diabetes' } },
+        'family-member-history-relationship': { valueCoding: { system: 'http://example.com', code: 'mother' } },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'FamilyMemberHistory',
+          status: 'completed',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addFamilyMemberHistory includes deceasedBoolean when provided', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addFamilyMemberHistory(medplum as any, patient, {
+        'family-member-history-problem': { valueCoding: { system: 'http://example.com', code: 'diabetes' } },
+        'family-member-history-relationship': { valueCoding: { system: 'http://example.com', code: 'mother' } },
+        'family-member-history-deceased': { valueBoolean: true },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          deceasedBoolean: true,
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addImmunization returns early without code or date', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource');
+      await addImmunization(medplum as any, patient, {
+        'immunization-vaccine': { valueCoding: { system: 'http://example.com', code: 'flu' } },
+      });
+      expect(upsertSpy).not.toHaveBeenCalled();
+    });
+
+    test('addImmunization upserts when code and date present', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      await addImmunization(medplum as any, patient, {
+        'immunization-vaccine': { valueCoding: { system: 'http://example.com', code: 'flu' } },
+        'immunization-date': { valueDateTime: '2024-01-01T00:00:00Z' },
+      });
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'Immunization',
+          status: 'completed',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    test('addPharmacy upserts CareTeam with pharmacy', async () => {
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const pharmacy: Reference<Organization> = { reference: 'Organization/pharmacy-1' };
+      await addPharmacy(medplum as any, patient, pharmacy);
+      expect(upsertSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'CareTeam',
+          status: 'proposed',
+          name: 'Patient Preferred Pharmacy',
+        }),
+        expect.objectContaining({
+          name: 'Patient Preferred Pharmacy',
+          subject: `Patient/${patient.id}`,
+        })
+      );
+    });
+
+    test('addCoverage creates RelatedPerson when relationship requires it', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'child', system: 'http://example.com' } },
+        'related-person': {
+          'related-person-first-name': { valueString: 'John' },
+          'related-person-last-name': { valueString: 'Doe' },
+        } as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage does not create RelatedPerson for self relationship', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource');
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'self', system: 'http://example.com' } },
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).not.toHaveBeenCalled();
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage does not create RelatedPerson for other relationship', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource');
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'other', system: 'http://example.com' } },
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).not.toHaveBeenCalled();
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage does not create RelatedPerson for injured relationship', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource');
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'injured', system: 'http://example.com' } },
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).not.toHaveBeenCalled();
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage does not create RelatedPerson when relationship code is missing', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource');
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { system: 'http://example.com' } },
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).not.toHaveBeenCalled();
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage does not create RelatedPerson when relatedPersonAnswers is missing', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource');
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'child', system: 'http://example.com' } },
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).not.toHaveBeenCalled();
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage creates RelatedPerson with birthDate and gender', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'parent', system: 'http://example.com' } },
+        'related-person': {
+          'related-person-first-name': { valueString: 'John' },
+          'related-person-last-name': { valueString: 'Doe' },
+          'related-person-dob': { valueDate: '1980-01-01' },
+          'related-person-gender-identity': { valueCoding: { code: 'male', system: 'http://example.com' } },
+        } as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+          birthDate: '1980-01-01',
+          gender: 'male',
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage creates RelatedPerson with parent relationship', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'parent', system: 'http://example.com' } },
+        'related-person': {
+          'related-person-first-name': { valueString: 'John' },
+          'related-person-last-name': { valueString: 'Doe' },
+        } as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+          relationship: [
+            {
+              coding: [
+                { system: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode', code: 'CHILD', display: 'child' },
+              ],
+            },
+          ],
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage creates RelatedPerson with spouse relationship', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'spouse', system: 'http://example.com' } },
+        'related-person': {
+          'related-person-first-name': { valueString: 'Jane' },
+          'related-person-last-name': { valueString: 'Doe' },
+        } as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+          relationship: [
+            {
+              coding: [{ system: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode', code: 'SPS', display: 'spouse' }],
+            },
+          ],
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage creates RelatedPerson with common relationship (treated as spouse)', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'common', system: 'http://example.com' } },
+        'related-person': {
+          'related-person-first-name': { valueString: 'Jane' },
+          'related-person-last-name': { valueString: 'Doe' },
+        } as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+          relationship: [
+            {
+              coding: [{ system: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode', code: 'SPS', display: 'spouse' }],
+            },
+          ],
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage creates RelatedPerson with undefined relationship when code not mapped', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'unknown-relationship', system: 'http://example.com' } },
+        'related-person': {
+          'related-person-first-name': { valueString: 'Jane' },
+          'related-person-last-name': { valueString: 'Doe' },
+        } as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+          relationship: undefined,
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+
+    test('addCoverage creates RelatedPerson without name when name is undefined', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({} as any);
+      const upsertSpy = vi.spyOn(medplum, 'upsertResource').mockResolvedValue({} as any);
+      const answers: Record<string, QuestionnaireResponseItemAnswer> = {
+        'insurance-provider': { valueReference: { reference: 'Organization/org-1' } as Reference<Organization> },
+        'subscriber-id': { valueString: 'sub-1' },
+        'relationship-to-subscriber': { valueCoding: { code: 'child', system: 'http://example.com' } },
+        'related-person': {} as any,
+      };
+
+      await addCoverage(medplum as any, patient, answers);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'RelatedPerson',
+          name: undefined,
+        })
+      );
+      expect(upsertSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('getGroupRepeatedAnswers edge cases', () => {
+    test('handles items with nested subgroups and answers', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [
+          {
+            linkId: 'group',
+            type: 'group',
+            item: [
+              { linkId: 'field1', type: 'string' },
+              {
+                linkId: 'subgroup',
+                type: 'group',
+                item: [{ linkId: 'subfield1', type: 'string' }],
+              },
+            ],
+          },
+        ],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [
+          {
+            linkId: 'group',
+            item: [
+              { linkId: 'field1', answer: [{ valueString: 'value1' }] },
+              {
+                linkId: 'subgroup',
+                item: [{ linkId: 'subfield1', answer: [{ valueString: 'subvalue1' }] }],
+              },
+            ],
+          },
+        ],
+      };
+
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'group');
+      expect(answers).toEqual([
+        {
+          field1: { valueString: 'value1' },
+          subgroup: { subfield1: { valueString: 'subvalue1' } },
+        },
+      ]);
+    });
+
+    test('handles items without answers in nested subgroups', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [
+          {
+            linkId: 'group',
+            type: 'group',
+            item: [
+              {
+                linkId: 'subgroup',
+                type: 'group',
+                item: [{ linkId: 'subfield1', type: 'string' }],
+              },
+            ],
+          },
+        ],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [
+          {
+            linkId: 'group',
+            item: [
+              {
+                linkId: 'subgroup',
+                item: [{ linkId: 'subfield1' }], // No answer
+              },
+            ],
+          },
+        ],
+      };
+
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'group');
+      // When there's no answer, it returns an empty object
+      expect(answers).toEqual([
+        {
+          subgroup: {},
+        },
+      ]);
+    });
+
+    test('handles items with empty answer arrays', () => {
+      const questionnaire: Questionnaire = {
+        status: 'active',
+        resourceType: 'Questionnaire',
+        item: [
+          {
+            linkId: 'group',
+            type: 'group',
+            item: [{ linkId: 'field1', type: 'string' }],
+          },
+        ],
+      };
+      const response: QuestionnaireResponse = {
+        status: 'completed',
+        resourceType: 'QuestionnaireResponse',
+        item: [
+          {
+            linkId: 'group',
+            item: [{ linkId: 'field1', answer: [] }],
+          },
+        ],
+      };
+
+      const answers = getGroupRepeatedAnswers(questionnaire, response, 'group');
+      expect(answers).toEqual([
+        {
+          field1: {},
+        },
+      ]);
+    });
+  });
+});