@tellescope/sdk 2.0.0-beta.1 → 2.0.0-beta.3

package/src/tests/api_tests/mdi_manual_sync.test.ts

@@ -0,0 +1,277 @@
+require('source-map-support').install();
+
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
+import { MD_INTEGRATIONS_TITLE } from "@tellescope/constants"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+/**
+ * Manual MD Integrations re-sync — guard coverage.
+ *   - form_responses.push_to_EHR with target === MD_INTEGRATIONS_TITLE (re-runs create_case)
+ *   - files.push with destination === MD_INTEGRATIONS_TITLE (attaches one file to an existing case)
+ *
+ * Nothing here may reach MDI: the payload is patient PHI and there is no HTTP stub. Every assertion
+ * stops at a guard that rejects before the first MDI request:
+ *   - responses are submitted BEFORE the placeholder MDI integration exists, so the automatic
+ *     create_case on submit finds no integration and skips
+ *   - the enduser lacks dateOfBirth, so create_case's pre-validation throws before any upload,
+ *     patient or case request (which is also what this suite checks)
+ *
+ * Also covers confirm_file_upload's optional mdiFileType (validation only).
+ *
+ * A failed sync is recorded on FormResponse.mdiSyncError (server-written, read-only via the API);
+ * a failure that is only missing demographics creates no background error.
+ *
+ * Not covered (manual sandbox QA): the "already synced" guards keyed on references (read-only
+ * through the API), the successful sync, and mdiSyncError being cleared by it.
+ */
+
+export const mdi_manual_sync_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let provisioned: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  // Resolves to the error message, or '' when the call unexpectedly succeeded
+  const errorOf = async (f: () => Promise<any>) => {
+    try {
+      await f()
+      return ''
+    } catch (err: any) {
+      return (err?.message || err?.toString?.() || JSON.stringify(err)) as string
+    }
+  }
+
+  try {
+    provisioned = await setup_isolated_tenant()
+    const { sdk } = provisioned
+
+    // Every required MDI demographic except dateOfBirth
+    const enduser = await sdk.api.endusers.createOne({
+      fname: 'Mdi', lname: 'Sync',
+      email: `mdi_manual_sync_${Date.now()}@test.tellescope.com`,
+      phone: '+15555550123',
+      addressLineOne: '1 Main St', city: 'Springfield', state: 'CA', zipCode: '12345',
+    })
+
+    const mdiForm = await sdk.api.forms.createOne({
+      title: 'MDI Manual Sync Form',
+      mdiCaseOfferings: [{ offering_id: 'test-offering' }],
+    })
+    const plainForm = await sdk.api.forms.createOne({ title: 'Non-MDI Manual Sync Form' })
+
+    // A form needs at least one field + a matching answer to be submittable
+    const fieldFor = async (formId: string) => sdk.api.form_fields.createOne({
+      formId, type: 'string', title: 'Field', previousFields: [{ type: 'root', info: {} }],
+    })
+    const mdiField = await fieldFor(mdiForm.id)
+    const plainField = await fieldFor(plainForm.id)
+
+    const submit = async (formId: string, fieldId: string) => {
+      const { accessCode, response } = await sdk.api.form_responses.prepare_form_response({ enduserId: enduser.id, formId })
+      await sdk.api.form_responses.submit_form_response({
+        accessCode,
+        responses: [{ fieldId, fieldTitle: 'Field', answer: { type: 'string', value: 'x' } }],
+      })
+      return response.id
+    }
+
+    // Submitted while no MDI integration exists → the automatic sync skips (no MDI request)
+    const plainResponseId = await submit(plainForm.id, plainField.id)
+    const mdiResponseId = await submit(mdiForm.id, mdiField.id)
+    const mdiStatusResponseId = await submit(mdiForm.id, mdiField.id)
+    const { response: draft } = await sdk.api.form_responses.prepare_form_response({ enduserId: enduser.id, formId: mdiForm.id })
+
+    const pushResponse = (id: string) => () => sdk.api.form_responses.push_to_EHR({ id, target: MD_INTEGRATIONS_TITLE })
+
+    // ── A. push_to_EHR guards that need no integration ─────────────────────────
+    const draftError = await errorOf(pushResponse(draft.id))
+    record('A1: an unsubmitted response is rejected', /has not been submitted/i.test(draftError), draftError)
+
+    const plainError = await errorOf(pushResponse(plainResponseId))
+    record('A2: a form without mdiCaseOfferings is rejected as not configured', /not configured for MD Integrations/i.test(plainError), plainError)
+
+    const noIntegrationError = await errorOf(pushResponse(mdiResponseId))
+    record('A3: no MDI integration is rejected', /MD Integrations integration not found/i.test(noIntegrationError), noIntegrationError)
+
+    // Placeholder integration (same shape as mdi_trigger_refill.test.ts). Only created after every
+    // submission above, so no automatic create_case ever saw it.
+    await sdk.api.integrations.createOne({
+      title: MD_INTEGRATIONS_TITLE,
+      authentication: {
+        type: 'oauth2',
+        info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
+      },
+    } as any)
+
+    // ── B. missing demographics fail before anything is sent to MDI ────────────
+    const missingDobError = await errorOf(pushResponse(mdiResponseId))
+    record(
+      'B1: an enduser missing dateOfBirth is rejected, naming the field',
+      /missing required fields for MD Integrations/i.test(missingDobError) && /dateOfBirth/.test(missingDobError),
+      missingDobError,
+    )
+
+    // Missing demographics are recorded on the response (B3), NOT as a background error, which is
+    // kept for real MDI/API failures. createBackgroundError is fire-and-forget, so allow time for a
+    // stray insert to land before concluding there is none.
+    await new Promise(resolve => setTimeout(resolve, 1500))
+    const backgroundErrors = (await sdk.api.background_errors.getSome() ?? [])
+      .filter(r => r.title.startsWith('MD Integrations Error') && r.message.includes(mdiResponseId))
+    record(
+      'B2: a missing-fields failure creates no background error',
+      backgroundErrors.length === 0,
+      backgroundErrors.length ? backgroundErrors.map(r => r.title).join(', ') : 'none',
+    )
+
+    // The failure is also recorded on the form response itself
+    const afterFailure = (await sdk.api.form_responses.getOne(mdiResponseId)).mdiSyncError
+    record(
+      'B3: the form response records mdiSyncError with the missing fields',
+      !!afterFailure
+        && afterFailure.missingFields?.join(',') === 'dateOfBirth'
+        && /dateOfBirth/.test(afterFailure.message)
+        && !!afterFailure.at,
+      JSON.stringify(afterFailure),
+    )
+
+    const retryError = await errorOf(pushResponse(mdiResponseId))
+    record(
+      'B4: the lock is released after a failed sync (a retry reaches validation again)',
+      /dateOfBirth/.test(retryError),
+      retryError,
+    )
+
+    const afterRetry = (await sdk.api.form_responses.getOne(mdiResponseId)).mdiSyncError
+    record(
+      'B5: a failed retry refreshes mdiSyncError.at',
+      !!afterFailure?.at && !!afterRetry?.at && new Date(afterRetry.at).getTime() > new Date(afterFailure.at).getTime(),
+      `first=${afterFailure?.at} retry=${afterRetry?.at}`,
+    )
+
+    // Server-written only: clients must not be able to set or clear it
+    const writeError = await errorOf(() => sdk.api.form_responses.updateOne(mdiResponseId, {
+      mdiSyncError: { message: 'client-written', at: new Date() },
+    } as any))
+    const afterWrite = (await sdk.api.form_responses.getOne(mdiResponseId)).mdiSyncError
+    record(
+      'B6: mdiSyncError cannot be written through the API',
+      !!afterWrite && afterWrite.message !== 'client-written',
+      writeError || `no error; stored value: ${JSON.stringify(afterWrite)}`,
+    )
+
+    // ── C. a case reported by an MDI webhook (mdiStatus) blocks a retry ────────
+    await sdk.api.form_responses.updateOne(mdiStatusResponseId, { mdiStatus: 'Created' })
+    const mdiStatusError = await errorOf(pushResponse(mdiStatusResponseId))
+    record('C1: a response with mdiStatus is rejected as already having a case', /already has an MD Integrations case/i.test(mdiStatusError), mdiStatusError)
+
+    const guardOnly = (await sdk.api.form_responses.getOne(mdiStatusResponseId)).mdiSyncError
+    record(
+      'C2: a request rejected by an endpoint guard records no mdiSyncError',
+      !guardOnly,
+      JSON.stringify(guardOnly),
+    )
+
+    // ── D. files.push(destination=MDI) guards ──────────────────────────────────
+    // File DB records only (prepare_file_upload, no S3 upload): the guards only read the record.
+    // prepare_file_upload still signs an S3 upload URL, so the API needs AWS credentials; without
+    // them this section records one failing check instead of discarding A–C's results.
+    const createFileRecord = async (name: string, source?: string) => (
+      (await sdk.api.files.prepare_file_upload({ name, type: 'text/plain', size: 1, enduserId: enduser.id, source })).file
+    )
+    const pushFile = (id: string) => () => sdk.api.files.push({ id, destination: MD_INTEGRATIONS_TITLE })
+
+    try {
+      const unlinkedFile = await createFileRecord('mdi-unlinked.txt')
+      const unlinkedError = await errorOf(pushFile(unlinkedFile.id))
+      record('D1: a file with no form response is rejected', /not associated with a form response/i.test(unlinkedError), unlinkedError)
+
+      const fromMdiFile = await createFileRecord('mdi-inbound.txt', MD_INTEGRATIONS_TITLE)
+      await sdk.api.files.updateOne(fromMdiFile.id, { formResponseId: mdiResponseId })
+      const fromMdiError = await errorOf(pushFile(fromMdiFile.id))
+      record('D2: a file that came from MDI is rejected', /came from MD Integrations/i.test(fromMdiError), fromMdiError)
+
+      const noCaseFile = await createFileRecord('mdi-no-case.txt')
+      await sdk.api.files.updateOne(noCaseFile.id, { formResponseId: mdiResponseId })
+      const noCaseError = await errorOf(pushFile(noCaseFile.id))
+      record(
+        'D3: a file whose form response has no MDI case points to the form-response sync',
+        /no MD Integrations case yet/i.test(noCaseError),
+        noCaseError,
+      )
+    } catch (err: any) {
+      record(
+        'D: files.push guards could not run (prepare_file_upload failed — does the API have AWS credentials?)',
+        false,
+        err?.message || String(err),
+      )
+    }
+
+    // ── E. confirm_file_upload's optional mdiFileType (moved from mdi_file_sync.test.ts) ──
+    // Validation only. The response has no MDI case and the enduser no MDI patient, so each
+    // fire-and-forget sync stops at target resolution, before any MDI request.
+    try {
+      for (const mdiFileType of ['driver-license', 'face-photo'] as const) {
+        const typedFile = await createFileRecord(`${mdiFileType}.jpg`)
+        const typedError = await errorOf(() => sdk.api.files.confirm_file_upload({
+          id: typedFile.id, syncToMDI: true, formResponseId: mdiResponseId, mdiFileType,
+        }))
+        record(`E1: confirm_file_upload accepts mdiFileType ${mdiFileType}`, !typedError, typedError || 'accepted')
+      }
+
+      const invalidFile = await createFileRecord('invalid.jpg')
+      const invalidError = await errorOf(() => sdk.api.files.confirm_file_upload({
+        id: invalidFile.id, syncToMDI: true, formResponseId: mdiResponseId, mdiFileType: 'selfie' as any,
+      }))
+      record('E2: confirm_file_upload rejects an unknown mdiFileType', !!invalidError, invalidError || 'accepted, expected a validation error')
+
+      const untypedFile = await createFileRecord('untyped.jpg')
+      const untypedError = await errorOf(() => sdk.api.files.confirm_file_upload({
+        id: untypedFile.id, syncToMDI: true, formResponseId: mdiResponseId,
+      }))
+      const confirmed = await sdk.api.files.getOne(untypedFile.id)
+      record(
+        'E3: confirm_file_upload still works without mdiFileType',
+        !untypedError && !!confirmed.confirmedAt && confirmed.formResponseId === mdiResponseId,
+        untypedError || `confirmedAt=${confirmed.confirmedAt} formResponseId=${confirmed.formResponseId}`,
+      )
+    } catch (err: any) {
+      record(
+        'E: mdiFileType checks could not run (prepare_file_upload failed — does the API have AWS credentials?)',
+        false,
+        err?.message || String(err),
+      )
+    }
+  } finally {
+    if (provisioned) { try { await provisioned.teardown() } catch (e) { console.error('teardown failed', e) } }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const mdi_manual_sync_tests = async () => {
+  assert_checks('MD Integrations manual sync', await mdi_manual_sync_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'MD Integrations manual sync', run: mdi_manual_sync_checks }
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  mdi_manual_sync_tests()
+    .then(() => {
+      console.log("✅ MD Integrations manual sync test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ MD Integrations manual sync test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/api_tests/mdi_trigger_refill.test.ts

@@ -1,16 +1,17 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import {
-  async_test,
-  log_header,
-  passOnAnyResult,
-} from "@tellescope/testing"
 import { MD_INTEGRATIONS_TITLE } from "@tellescope/constants"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
 // MDI Trigger Refill journey action tests.
 //
 // Validator-acceptance plus handler-guard coverage: verifies that automation steps configured
@@ -19,9 +20,66 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
 // integration, missing patient reference) — no sandbox credentials needed. The happy path
 // (fetch cases -> find scheduled orders -> submit) requires an MDI sandbox with a
 // Direct-to-Pharmacy refill sequence and is covered by manual QA.
-export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("MDI Trigger Refill Journey Action Tests")
+//
+// Runs on its own provisioned tenant, which is what makes both handler guards reliable: a fresh
+// tenant never holds an MD Integrations integration, so the missing-integration guard is always
+// exercised and the placeholder integration is always created afterwards. On the shared fixture the
+// suite probed for an existing integration first and silently skipped one or both checks when the
+// org already had one — a skip reports green without asserting anything.
+export const mdi_trigger_refill_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  // The raw value decides the fallback, not JSON.stringify of it — JSON.stringify('') is '""',
+  // which is truthy, so a `|| fallback` on the stringified form could never fire.
+  const describe = (value: any): string => {
+    if (value === undefined || value === null) return String(value)
+    const stringified = JSON.stringify(value)
+    return stringified === undefined ? String(value) : stringified
+  }
+  const errorMessage = (e: any): string => (
+    typeof e?.message === 'string' && e.message !== '' ? e.message : describe(e)
+  )
+
+  /**
+   * The async_test({ onResult }) equivalent, as a soft Check: a call that REJECTS is a failure
+   * (async_test treats it the same way), and a resolved call passes only when onResult agrees.
+   *
+   * The call and the predicate are caught separately, so a predicate that throws fails THIS check
+   * with its own detail instead of being misreported as an API rejection — and never escapes `run`,
+   * which would fail the whole run once the batch settles rather than failing one check.
+   */
+  const expect_result = async <T,>(label: string, fn: () => Promise<T>, onResult: (r: T) => boolean) => {
+    let resolved: { value: T }
+    try {
+      resolved = { value: await fn() }
+    } catch (e: any) {
+      record(label, false, `rejected instead of resolving: ${errorMessage(e)}`)
+      return
+    }
+
+    const { value } = resolved
+    try {
+      record(label, onResult(value), `result=${describe(value)}`)
+    } catch (predicateError: any) {
+      record(label, false, `predicate threw on result=${describe(value)}: ${errorMessage(predicateError)}`)
+    }
+  }
 
+  /**
+   * The async_test({ shouldError: true, onError: () => true }) equivalent: a call that RESOLVES is a
+   * failure (async_test treats it the same way), and any rejection passes.
+   */
+  const expect_rejected = async (label: string, fn: () => Promise<any>) => {
+    try {
+      const unexpected = await fn()
+      record(label, false, `resolved instead of rejecting; result=${describe(unexpected)}`)
+    } catch (e: any) {
+      record(label, true, `rejected with ${errorMessage(e)}`)
+    }
+  }
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
   let journeyId: string | undefined
   const stepIds: string[] = []
   const automatedActionIds: string[] = []
@@ -29,11 +87,18 @@ export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
   let createdMDIIntegrationId: string | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `MDI trigger refill ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     const journey = await sdk.api.journeys.createOne({ title: 'MDI Trigger Refill Test Journey' })
     journeyId = journey.id
 
     // Full config accepted
-    await async_test(
+    await expect_result(
       "mdiTriggerRefill step accepted (onlySubmitWhenDue)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -43,11 +108,11 @@ export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
           info: { onlySubmitWhenDue: true },
         },
       }).then(s => { stepIds.push(s.id); return s }),
-      passOnAnyResult,
+      () => true,
     )
 
     // Empty info accepted (all fields optional)
-    await async_test(
+    await expect_result(
       "mdiTriggerRefill step accepted (empty info)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -57,11 +122,11 @@ export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
           info: {},
         },
       }).then(s => { stepIds.push(s.id); return s }),
-      passOnAnyResult,
+      () => true,
     )
 
     // Wrong type for onlySubmitWhenDue rejected
-    await async_test(
+    await expect_rejected(
       "mdiTriggerRefill step rejected (non-boolean onlySubmitWhenDue)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -71,12 +136,11 @@ export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
           info: { onlySubmitWhenDue: 'yes' },
         } as any,
       }),
-      { shouldError: true, onError: () => true },
     )
 
     // Unexpected info fields are stripped by objectValidator, not rejected — assert they never
     // reach the stored config (the step itself is accepted)
-    await async_test(
+    await expect_result(
       "mdiTriggerRefill step strips unexpected info field",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -86,12 +150,10 @@ export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
           info: { onlySubmitWhenDue: false, formId: 'not-allowed' },
         } as any,
       }).then(s => { stepIds.push(s.id); return s }),
-      {
-        onResult: s => (
-          (s.action.info as any).onlySubmitWhenDue === false
-          && (s.action.info as any).formId === undefined
-        ),
-      },
+      s => (
+        (s.action.info as any).onlySubmitWhenDue === false
+        && (s.action.info as any).formId === undefined
+      ),
     )
 
     // ── Handler guards (process endpoint) ────────────────────────────────────────
@@ -109,70 +171,62 @@ export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
       processAfter: new Date().getTime() + 60 * 60 * 1000,
     } as any).then(a => { automatedActionIds.push(a.id); return a })
 
-    let mdiIntegrationExists = false
-    try {
-      const existing = await sdk.api.integrations.load_redacted({})
-      mdiIntegrationExists = !!existing.integrations.find((i: any) => i.title === MD_INTEGRATIONS_TITLE)
-    } catch { /* load not permitted — assume absent */ }
-
-    if (!mdiIntegrationExists) {
-      const noIntegrationAction = await createAutomatedAction()
-      await async_test(
-        "mdiTriggerRefill fails cleanly without an MDI integration",
-        () => sdk.api.automated_actions.process({ automatedActionId: noIntegrationAction.id }),
-        { onResult: (r: any) => r?.success === false && /MD Integrations integration not found/i.test(r?.error || '') },
-      )
-
-      try {
-        const created = await sdk.api.integrations.createOne({
-          title: MD_INTEGRATIONS_TITLE,
-          authentication: {
-            type: 'oauth2',
-            info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
-          },
-        } as any)
-        createdMDIIntegrationId = created.id
-        mdiIntegrationExists = true
-      } catch (e) {
-        console.log("Could not create an MDI integration; skipping patient-reference guard test:", e)
-      }
-    } else {
-      console.log("⏭️  Skipping mdiTriggerRefill missing-integration guard test (an MDI integration already exists)")
-    }
+    // A freshly provisioned tenant holds no MD Integrations integration, so this guard is always
+    // reached — no probe and no skip branch.
+    const noIntegrationAction = await createAutomatedAction()
+    await expect_result(
+      "mdiTriggerRefill fails cleanly without an MDI integration",
+      () => sdk.api.automated_actions.process({ automatedActionId: noIntegrationAction.id }),
+      (r: any) => r?.success === false && /MD Integrations integration not found/i.test(r?.error || ''),
+    )
 
-    if (mdiIntegrationExists) {
-      // enduser has no MD Integrations reference — the guard returns before any outbound MDI call
-      const noReferenceAction = await createAutomatedAction()
-      await async_test(
-        "mdiTriggerRefill fails cleanly for an enduser with no MDI patient reference",
-        () => sdk.api.automated_actions.process({ automatedActionId: noReferenceAction.id }),
-        { onResult: (r: any) => r?.success === false && /no MD Integrations patient reference/i.test(r?.error || '') },
-      )
-    }
+    const created = await sdk.api.integrations.createOne({
+      title: MD_INTEGRATIONS_TITLE,
+      authentication: {
+        type: 'oauth2',
+        info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
+      },
+    } as any)
+    createdMDIIntegrationId = created.id
+
+    // enduser has no MD Integrations reference — the guard returns before any outbound MDI call
+    const noReferenceAction = await createAutomatedAction()
+    await expect_result(
+      "mdiTriggerRefill fails cleanly for an enduser with no MDI patient reference",
+      () => sdk.api.automated_actions.process({ automatedActionId: noReferenceAction.id }),
+      (r: any) => r?.success === false && /no MD Integrations patient reference/i.test(r?.error || ''),
+    )
   } finally {
-    for (const id of automatedActionIds) {
-      await sdk.api.automated_actions.deleteOne(id).catch(console.error)
-    }
-    if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(console.error)
-    if (createdMDIIntegrationId) await sdk.api.integrations.deleteOne(createdMDIIntegrationId).catch(console.error)
-    for (const id of stepIds) {
-      await sdk.api.automation_steps.deleteOne(id).catch(console.error)
+    if (tenant) {
+      const { sdk } = tenant
+      for (const id of automatedActionIds) {
+        await sdk.api.automated_actions.deleteOne(id).catch(console.error)
+      }
+      if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(console.error)
+      if (createdMDIIntegrationId) await sdk.api.integrations.deleteOne(createdMDIIntegrationId).catch(console.error)
+      for (const id of stepIds) {
+        await sdk.api.automation_steps.deleteOne(id).catch(console.error)
+      }
+      if (journeyId) await sdk.api.journeys.deleteOne(journeyId).catch(console.error)
+      // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+      try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) }
     }
-    if (journeyId) await sdk.api.journeys.deleteOne(journeyId).catch(console.error)
   }
+
+  return checks
 }
 
-if (require.main === module) {
-  console.log(`Using API URL: ${host}`)
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const mdi_trigger_refill_tests = async () => {
+  assert_checks('MDI trigger refill', await mdi_trigger_refill_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await mdi_trigger_refill_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'MDI trigger refill', run: mdi_trigger_refill_checks }
 
-  runTests()
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  mdi_trigger_refill_tests()
     .then(() => {
       console.log("✅ MDI trigger refill test suite completed successfully")
       process.exit(0)