@unite-us/app-create-referral 0.15.176 → 0.15.177

package/dist/hooks/__tests__/useCreateReferrals.test.js

@@ -1,8 +1,8 @@
 import { renderHook, act } from '@testing-library/react-hooks';
 import useCreateReferrals from '../useCreateReferrals';
 import { useAppCreateReferralContext } from '../../context/AppCreateReferralProvider';
-import { useCreateRecord, useUpdateRecord } from '../../api/ApiHooks';
-import { coreApi } from '../../api/config';
+import { useAtomicOperations, useCreateRecord, useUpdateRecord } from '../../api/ApiHooks';
+import { coreApi, FEATURE_FLAGS } from '../../api/config';
 jest.mock('../../context/AppCreateReferralProvider', () => ({
   useAppCreateReferralContext: jest.fn(),
   setData: data => ({
@@ -11,6 +11,7 @@ jest.mock('../../context/AppCreateReferralProvider', () => ({
   })
 }));
 jest.mock('../../api/ApiHooks', () => ({
+  useAtomicOperations: jest.fn(),
   useCreateRecord: jest.fn(),
   useUpdateRecord: jest.fn()
 }));
@@ -24,6 +25,7 @@ jest.mock('../../api/config', () => ({
     query: jest.fn(),
     uploadFile: jest.fn()
   },
+  FEATURE_FLAGS: {},
   CALLBACKS: {
     notify: {
       error: jest.fn()
@@ -87,6 +89,7 @@ describe('useCreateReferrals', () => {
         service_start: null,
         service_end: null
       },
+      description: 'Test Referral',
       programs: [{
         id: 'program1',
         provider: {
@@ -364,6 +367,14 @@ describe('useCreateReferrals', () => {
   };
   beforeEach(() => {
     jest.clearAllMocks();
+    Object.keys(FEATURE_FLAGS).forEach(key => delete FEATURE_FLAGS[key]);
+    useAtomicOperations.mockReturnValue({
+      atomicOperations: jest.fn().mockResolvedValue({
+        data: {
+          'atomic:results': []
+        }
+      })
+    });
     coreApi.deleteFile.mockResolvedValue({});
     coreApi.deleteRecord.mockResolvedValue({});
     coreApi.findRecord.mockResolvedValue({
@@ -381,6 +392,645 @@ describe('useCreateReferrals', () => {
       }
     });
   });
+  it('creates a new referral group in one atomic operation when enabled', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const atomicOperations = jest.fn().mockResolvedValue({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case1',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'referral1',
+            state: 'sent'
+          }
+        }]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referrals);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    await act(async () => {
+      const response = await result.current({
+        draft: false
+      });
+      expect(response).toEqual({
+        cases: [{
+          id: 'case1',
+          description: 'Test Case'
+        }],
+        referrals: [{
+          id: 'referral1',
+          state: 'sent',
+          referralIndex: 0
+        }],
+        shippingDetail: [{
+          id: 'referral-result-0',
+          index: 0,
+          sent: true,
+          error: null,
+          caseId: 'case1',
+          attachmentStatus: 'not_requested',
+          attachmentErrors: [],
+          rawAtomicErrors: null
+        }],
+        referralsToConsent: [{
+          programNames: ['Unknown Program'],
+          referrals: ['referral1'],
+          serviceName: 'Unknown Service'
+        }]
+      });
+    });
+    expect(atomicOperations).toHaveBeenCalledTimes(1);
+    const submittedOperations = atomicOperations.mock.calls[0][0];
+    expect(submittedOperations).toHaveLength(2);
+    const [caseOp, referralOp] = submittedOperations;
+    expect(caseOp).toMatchObject({
+      op: 'add',
+      model: 'case',
+      lid: 'case-0'
+    });
+    expect(referralOp).toMatchObject({
+      op: 'add',
+      model: 'referral',
+      data: expect.objectContaining({
+        case: {
+          lid: 'case-0'
+        },
+        receiving_program: 'program1'
+      })
+    });
+  });
+  it('includes existing documents in the atomic request without calling setRelationship', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const referralWithExistingDocument = [createBaseReferral({
+      attachableDocuments: [{
+        attached: true,
+        document: {
+          id: 'existing-doc-1',
+          title: 'Existing Document'
+        }
+      }]
+    })];
+    const atomicOperations = jest.fn().mockResolvedValue({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case1',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'referral1',
+            state: 'sent'
+          }
+        }, {}]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referralWithExistingDocument);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    await act(async () => {
+      await result.current({
+        draft: false
+      });
+    });
+    const submittedOperations = atomicOperations.mock.calls[0][0];
+    expect(submittedOperations).toHaveLength(3);
+    expect(coreApi.setRelationship).not.toHaveBeenCalled();
+    const [caseOp, referralOp, relationshipOp] = submittedOperations;
+    expect(caseOp).toMatchObject({
+      op: 'add',
+      model: 'case',
+      lid: 'case-0'
+    });
+    expect(referralOp).toMatchObject({
+      op: 'add',
+      model: 'referral',
+      data: expect.objectContaining({
+        case: {
+          lid: 'case-0'
+        }
+      })
+    });
+    expect(relationshipOp).toMatchObject({
+      op: 'add',
+      model: 'case',
+      lid: 'case-0',
+      relationship: 'file_uploads',
+      relationshipModel: 'file_upload',
+      value: ['existing-doc-1']
+    });
+  });
+  it('does not upload attachments when the atomic referral group fails', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const pendingFile = {
+      name: 'pending.pdf',
+      type: 'application/pdf'
+    };
+    const referralWithAttachment = [createBaseReferral({
+      pendingAttachments: [{
+        tempId: 'file-1',
+        file: pendingFile
+      }]
+    })];
+    const atomicOperations = jest.fn().mockRejectedValue({
+      response: {
+        data: {
+          errors: [{
+            title: 'Referral operation failed'
+          }]
+        }
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referralWithAttachment);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(response).toMatchObject({
+      cases: [],
+      referrals: [],
+      shippingDetail: [{
+        sent: false,
+        error: 'Error creating the Referral: Referral operation failed',
+        caseId: null,
+        attachmentStatus: 'not_requested'
+      }]
+    });
+    expect(coreApi.uploadFile).not.toHaveBeenCalled();
+    const submittedOperations = atomicOperations.mock.calls[0][0];
+    expect(submittedOperations).toHaveLength(2);
+    const [caseOp, referralOp] = submittedOperations;
+    expect(caseOp).toMatchObject({
+      op: 'add',
+      model: 'case',
+      lid: 'case-0'
+    });
+    expect(referralOp).toMatchObject({
+      op: 'add',
+      model: 'referral',
+      data: expect.objectContaining({
+        case: {
+          lid: 'case-0'
+        }
+      })
+    });
+  });
+  it('includes service_authorization in atomic operations when authorization is required', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const referralWithAuth = [createBaseReferral({
+      paymentAuthForm: {
+        amount_requested: 500,
+        service_start: 1724500000,
+        service_end: 1727100000
+      },
+      programs: [{
+        id: 'program1',
+        provider: {
+          id: 'provider1',
+          licensed: true
+        },
+        fee_schedule_program: {
+          id: 'fsp-1',
+          authorization_required: true,
+          payment_type: 'fee_for_service',
+          fee_schedule: {
+            id: 'fee-schedule-1'
+          }
+        }
+      }]
+    })];
+    const atomicOperations = jest.fn().mockResolvedValue({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case1',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'auth1',
+            state: 'requested'
+          }
+        }, {
+          data: {
+            id: 'referral1',
+            state: 'pending_authorization'
+          }
+        }]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referralWithAuth);
+    coreApi.query.mockResolvedValue({
+      data: {
+        data: [{
+          id: 'insurance-1'
+        }]
+      }
+    });
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(response.referrals[0]).toMatchObject({
+      id: 'referral1',
+      state: 'pending_authorization'
+    });
+    expect(atomicOperations).toHaveBeenCalledTimes(1);
+    const submittedOperations = atomicOperations.mock.calls[0][0];
+    expect(submittedOperations).toHaveLength(3);
+    const [caseOp, authOp, referralOp] = submittedOperations;
+    expect(caseOp).toMatchObject({
+      op: 'add',
+      model: 'case'
+    });
+    expect(authOp).toMatchObject({
+      op: 'add',
+      model: 'service_authorization',
+      data: expect.objectContaining({
+        case: {
+          lid: 'case-0'
+        },
+        fee_schedule_program: 'fsp-1',
+        insurance: 'insurance-1',
+        state: 'requested'
+      })
+    });
+    expect(referralOp).toMatchObject({
+      op: 'add',
+      model: 'referral',
+      data: expect.objectContaining({
+        case: {
+          lid: 'case-0'
+        },
+        state: 'pending_authorization'
+      })
+    });
+  });
+  it('does not submit atomic operations when referral values are missing', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const atomicOperations = jest.fn();
+    const referralWithoutProgramId = [createBaseReferral({
+      programs: [{
+        provider: {
+          id: 'provider1',
+          licensed: true
+        }
+      }]
+    })];
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referralWithoutProgramId);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(atomicOperations).not.toHaveBeenCalled();
+    expect(response.shippingDetail[0]).toMatchObject({
+      sent: false,
+      error: 'The following fields for the referral are required: receiving_program',
+      caseId: null
+    });
+  });
+  it('creates multiple referrals in one atomic operation for grouped referrals', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const groupedReferral = [createBaseReferral({
+      programs: [{
+        id: 'program1',
+        provider: {
+          id: 'provider1',
+          licensed: true
+        }
+      }, {
+        id: 'program2',
+        provider: {
+          id: 'provider2',
+          licensed: true
+        }
+      }, {
+        id: 'program3',
+        provider: {
+          id: 'provider3',
+          licensed: true
+        }
+      }]
+    })];
+    const atomicOperations = jest.fn().mockResolvedValue({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case1',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'referral1',
+            state: 'sent'
+          }
+        }, {
+          data: {
+            id: 'referral2',
+            state: 'sent'
+          }
+        }, {
+          data: {
+            id: 'referral3',
+            state: 'sent'
+          }
+        }]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(groupedReferral);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(atomicOperations).toHaveBeenCalledTimes(1);
+    const submittedOperations = atomicOperations.mock.calls[0][0];
+    expect(submittedOperations).toHaveLength(4);
+    const [caseOp, ...referralOps] = submittedOperations;
+    expect(caseOp).toMatchObject({
+      op: 'add',
+      model: 'case'
+    });
+    referralOps.forEach((op, idx) => {
+      expect(op).toMatchObject({
+        op: 'add',
+        model: 'referral',
+        data: expect.objectContaining({
+          case: {
+            lid: 'case-0'
+          },
+          is_grouped: true,
+          receiving_program: `program${idx + 1}`
+        })
+      });
+    });
+    expect(response.referrals).toHaveLength(3);
+    expect(response.referrals.map(r => r.id)).toEqual(['referral1', 'referral2', 'referral3']);
+    expect(response.cases).toHaveLength(1);
+  });
+  it('stashes the raw atomic errors on the shipping detail without changing the user-facing message', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const rawErrors = [{
+      title: 'Referral operation failed',
+      source: {
+        pointer: '/atomic:operations/1'
+      }
+    }];
+    const atomicOperations = jest.fn().mockRejectedValue({
+      response: {
+        data: {
+          errors: rawErrors
+        }
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referrals);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(response.shippingDetail[0]).toMatchObject({
+      error: 'Error creating the Referral: Referral operation failed',
+      rawAtomicErrors: rawErrors
+    });
+  });
+  it('does not corrupt later groups when an earlier atomic group fails mid-batch', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const twoReferrals = [createBaseReferral({
+      description: 'Failing referral'
+    }), createBaseReferral({
+      description: 'Succeeding referral'
+    })];
+    const atomicOperations = jest.fn().mockRejectedValueOnce({
+      response: {
+        data: {
+          errors: [{
+            title: 'Referral operation failed'
+          }]
+        }
+      }
+    }).mockResolvedValueOnce({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case2',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'referral2',
+            state: 'sent'
+          }
+        }]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(twoReferrals);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(atomicOperations).toHaveBeenCalledTimes(2);
+    expect(response.shippingDetail[0]).toMatchObject({
+      sent: false,
+      error: 'Error creating the Referral: Referral operation failed',
+      caseId: null
+    });
+    expect(response.shippingDetail[1]).toMatchObject({
+      sent: true,
+      caseId: 'case2',
+      error: null
+    });
+    expect(response.cases).toEqual([{
+      id: 'case2',
+      description: 'Test Case'
+    }]);
+    expect(response.referrals).toEqual([{
+      id: 'referral2',
+      state: 'sent',
+      referralIndex: 1
+    }]);
+  });
+  it('uploads only the pending attachments on the atomic path', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const pendingFile = {
+      name: 'pending.pdf',
+      type: 'application/pdf'
+    };
+    const referralWithAttachment = [createBaseReferral({
+      pendingAttachments: [{
+        tempId: 'file-1',
+        file: pendingFile
+      }]
+    })];
+    const atomicOperations = jest.fn().mockResolvedValue({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case1',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'referral1',
+            state: 'sent'
+          }
+        }]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referralWithAttachment);
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    await act(async () => {
+      await result.current({
+        draft: false
+      });
+    });
+    expect(coreApi.uploadFile).toHaveBeenCalledTimes(1);
+    expect(coreApi.uploadFile).toHaveBeenCalledWith('case', 'case1', pendingFile);
+  });
+  it('reports the upload failure separately while the referral stays successful', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const pendingFile = {
+      name: 'pending.pdf',
+      type: 'application/pdf'
+    };
+    const referralWithAttachment = [createBaseReferral({
+      pendingAttachments: [{
+        tempId: 'file-1',
+        file: pendingFile
+      }]
+    })];
+    const atomicOperations = jest.fn().mockResolvedValue({
+      data: {
+        'atomic:results': [{
+          data: {
+            id: 'case1',
+            description: 'Test Case'
+          }
+        }, {
+          data: {
+            id: 'referral1',
+            state: 'sent'
+          }
+        }]
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referralWithAttachment);
+    coreApi.uploadFile.mockRejectedValue(new Error('Upload failed'));
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    let response;
+    await act(async () => {
+      response = await result.current({
+        draft: false
+      });
+    });
+    expect(response.shippingDetail[0]).toMatchObject({
+      sent: true,
+      caseId: 'case1',
+      attachmentStatus: 'failed'
+    });
+    expect(response.referrals).toEqual([{
+      id: 'referral1',
+      state: 'sent',
+      referralIndex: 0
+    }]);
+  });
+  it('does not fall back to legacy create/update calls when an atomic group fails', async () => {
+    FEATURE_FLAGS.pays11587AtomicReferralCreation = true;
+    const atomicOperations = jest.fn().mockRejectedValue({
+      response: {
+        data: {
+          errors: [{
+            title: 'Referral operation failed'
+          }]
+        }
+      }
+    });
+    useAtomicOperations.mockReturnValue({
+      atomicOperations
+    });
+    setupMocks(referrals);
+    const createRecord = jest.fn();
+    useCreateRecord.mockReturnValue({
+      createRecord
+    });
+    const {
+      result
+    } = renderHook(() => useCreateReferrals());
+    await act(async () => {
+      await result.current({
+        draft: false
+      });
+    });
+    expect(createRecord).not.toHaveBeenCalled();
+  });
   it('should validate response structure no matters the result', async () => {
     useAppCreateReferralContext.mockReturnValue({
       dispatch: mockDispatch,
@@ -519,7 +1169,8 @@ describe('useCreateReferrals', () => {
           error: null,
           caseId: 'case1',
           attachmentStatus: 'not_requested',
-          attachmentErrors: []
+          attachmentErrors: [],
+          rawAtomicErrors: null
         }],
         referralsToConsent: [{
           programNames: ['Unknown Program'],
@@ -608,7 +1259,8 @@ describe('useCreateReferrals', () => {
           error: null,
           caseId: 'case1',
           attachmentStatus: 'not_requested',
-          attachmentErrors: []
+          attachmentErrors: [],
+          rawAtomicErrors: null
         }, {
           id: 'referral-result-1',
           index: 1,
@@ -616,7 +1268,8 @@ describe('useCreateReferrals', () => {
           error: 'Unexpected error: The following fields for the case are required: description',
           caseId: null,
           attachmentStatus: 'not_requested',
-          attachmentErrors: []
+          attachmentErrors: [],
+          rawAtomicErrors: null
         }],
         referralsToConsent: [{
           programNames: ['Unknown Program'],
@@ -666,7 +1319,8 @@ describe('useCreateReferrals', () => {
           error: 'Unexpected error: The following fields for the case are required: description',
           caseId: null,
           attachmentStatus: 'not_requested',
-          attachmentErrors: []
+          attachmentErrors: [],
+          rawAtomicErrors: null
         }, {
           id: 'referral-result-1',
           index: 1,
@@ -674,7 +1328,8 @@ describe('useCreateReferrals', () => {
           error: 'Unexpected error: The following fields for the case are required: description',
           caseId: null,
           attachmentStatus: 'not_requested',
-          attachmentErrors: []
+          attachmentErrors: [],
+          rawAtomicErrors: null
         }],
         referralsToConsent: []
       });
@@ -721,7 +1376,8 @@ describe('useCreateReferrals', () => {
           error: null,
           caseId: 'case1',
           attachmentStatus: 'not_requested',
-          attachmentErrors: []
+          attachmentErrors: [],
+          rawAtomicErrors: null
         }],
         referralsToConsent: []
       });