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

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

@@ -1,15 +1,17 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import {
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
 import { BELUGA_TITLE } from "@tellescope/constants"
+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)
+
 // Manual Beluga re-sync guard tests (CU-86e1uxz1n).
 //   - form_responses.push_to_EHR with target === BELUGA_TITLE
 //   - files.push with destination === BELUGA_TITLE
@@ -18,11 +20,48 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
 // Beluga call. It performs NO S3 file uploads and triggers NO actual sync (both slow and require
 // live Beluga sandbox credentials). File records are created via prepare_file_upload alone — that
 // inserts the DB record, which is all the guards need.
-export const beluga_manual_sync_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Beluga Manual Sync Guard Tests (FormResponses & Files)")
+//
+// Runs on its own provisioned tenant, which is what makes the files.push guard reliable: a fresh
+// tenant never has a Beluga integration, so the placeholder is always created here and the guard is
+// always exercised. On the shared fixture the suite probed for an existing integration first and
+// silently skipped the whole check when it could not get one.
+export const beluga_manual_sync_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 errorMessage = (e: any): string => {
+    if (typeof e?.message === 'string' && e.message !== '') return e.message
+    if (e === undefined || e === null) return String(e)
+    const stringified = JSON.stringify(e)
+    return stringified === undefined ? String(e) : stringified
+  }
+
+  /**
+   * The async_test({ shouldError: true, onError }) equivalent, as a soft Check: a call that RESOLVES
+   * is a failure (async_test treats it the same way), and a rejection passes only when onError agrees.
+   */
+  const expect_rejected = async (label: string, fn: () => Promise<any>, onError: (e: any) => boolean) => {
+    let rejection: { e: any }
+    try {
+      const unexpected = await fn()
+      record(
+        label,
+        false,
+        `resolved instead of rejecting; result=${unexpected === undefined ? '(none)' : JSON.stringify(unexpected)}`,
+      )
+      return
+    } catch (e: any) {
+      rejection = { e }
+    }
 
-  const errorMessage = (e: any) => (e?.message || e?.toString?.() || JSON.stringify(e)) as string
+    // Outside the catch on purpose: a predicate that throws here would otherwise escape the suite
+    // and, per run_isolated_in_parallel, abort every remaining batch instead of failing one check.
+    record(label, onError(rejection.e), `rejected with ${errorMessage(rejection.e)}`)
+  }
 
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
   let enduserId: string | undefined
   let belugaFormId: string | undefined
   let plainFormId: string | undefined
@@ -30,6 +69,13 @@ export const beluga_manual_sync_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
   let createdBelugaIntegrationId: string | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Beluga manual sync guards ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     const enduser = await sdk.api.endusers.createOne({
       fname: 'beluga-sync',
       email: `beluga_manual_sync_${Date.now()}@test.tellescope.com`,
@@ -73,81 +119,85 @@ export const beluga_manual_sync_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sess
 
     // Unsubmitted draft → rejected before any integration lookup
     const { response: draft } = await sdk.api.form_responses.prepare_form_response({ enduserId: enduser.id, formId: belugaForm.id })
-    await async_test(
+    await expect_rejected(
       "push_to_EHR(target=BELUGA) rejects an unsubmitted form response",
       () => sdk.api.form_responses.push_to_EHR({ id: draft.id, target: BELUGA_TITLE }),
-      { shouldError: true, onError: (e: any) => /has not been submitted/i.test(errorMessage(e)) }
+      (e: any) => /has not been submitted/i.test(errorMessage(e)),
     )
 
     // Submitted, but the form has no belugaVisitType → rejected as not configured
     const plainResponseId = await submitForm(plainForm.id)
-    await async_test(
+    await expect_rejected(
       "push_to_EHR(target=BELUGA) rejects a form not configured for Beluga",
       () => sdk.api.form_responses.push_to_EHR({ id: plainResponseId, target: BELUGA_TITLE }),
-      { shouldError: true, onError: (e: any) => /not configured for Beluga/i.test(errorMessage(e)) }
+      (e: any) => /not configured for Beluga/i.test(errorMessage(e)),
     )
 
     // ──────────────────────────────────────────────────────────────────────────
     // 2. files.push(destination=BELUGA) guard — the endpoint resolves the destination
     //    integration first, so a Beluga integration must exist for the branch to be reached.
-    //    Create a placeholder if the org has none; skip gracefully if that's not permitted.
+    //    This tenant is brand new and holds none, so the placeholder is always created (no probe,
+    //    and no "skip gracefully" branch — a skip would report green without asserting anything).
     // ──────────────────────────────────────────────────────────────────────────
 
-    let belugaIntegrationAvailable = false
     try {
-      const existing = await sdk.api.integrations.load_redacted({})
-      belugaIntegrationAvailable = !!existing.integrations.find((i: any) => i.title === BELUGA_TITLE)
-    } catch { /* load not permitted — fall through to create attempt */ }
-
-    if (!belugaIntegrationAvailable) {
-      try {
-        const created = await sdk.api.integrations.createOne({
-          title: BELUGA_TITLE,
-          authentication: {
-            type: 'oauth2',
-            info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
-          },
-        })
-        createdBelugaIntegrationId = created.id
-        belugaIntegrationAvailable = true
-      } catch (e) {
-        console.log("Could not create a Beluga integration for testing; skipping files.push guard:", errorMessage(e))
-      }
+      const created = await sdk.api.integrations.createOne({
+        title: BELUGA_TITLE,
+        authentication: {
+          type: 'oauth2',
+          info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
+        },
+      })
+      createdBelugaIntegrationId = created.id
+    } catch (e: any) {
+      record(
+        'a placeholder Beluga integration can be created on a freshly provisioned tenant',
+        false,
+        `integration create failed, so the files.push guard below could not run: ${errorMessage(e)}`,
+      )
     }
 
-    if (belugaIntegrationAvailable) {
+    if (createdBelugaIntegrationId) {
       // A file with no associated formResponseId cannot be synced to Beluga
       const unlinkedFile = await createFileRecord('beluga-unlinked.txt')
-      await async_test(
+      await expect_rejected(
         "files.push(destination=BELUGA) rejects a file with no associated form response",
         () => sdk.api.files.push({ id: unlinkedFile.id, destination: BELUGA_TITLE }),
-        { shouldError: true, onError: (e: any) => /not associated with a form response/i.test(errorMessage(e)) }
+        (e: any) => /not associated with a form response/i.test(errorMessage(e)),
       )
-    } else {
-      console.log("⏭️  Skipping files.push(destination=BELUGA) guard (no Beluga integration available)")
     }
   } finally {
-    for (const id of fileIds) {
-      await sdk.api.files.deleteOne(id).catch(console.error)
+    if (tenant) {
+      const { sdk } = tenant
+      for (const id of fileIds) {
+        await sdk.api.files.deleteOne(id).catch(console.error)
+      }
+      if (belugaFormId) await sdk.api.forms.deleteOne(belugaFormId).catch(console.error)
+      if (plainFormId) await sdk.api.forms.deleteOne(plainFormId).catch(console.error)
+      if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(console.error)
+      if (createdBelugaIntegrationId) await sdk.api.integrations.deleteOne(createdBelugaIntegrationId).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 (belugaFormId) await sdk.api.forms.deleteOne(belugaFormId).catch(console.error)
-    if (plainFormId) await sdk.api.forms.deleteOne(plainFormId).catch(console.error)
-    if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(console.error)
-    if (createdBelugaIntegrationId) await sdk.api.integrations.deleteOne(createdBelugaIntegrationId).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 beluga_manual_sync_tests = async () => {
+  assert_checks('Beluga manual sync guards', await beluga_manual_sync_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await beluga_manual_sync_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Beluga manual sync guards',
+  run: beluga_manual_sync_checks,
+}
 
-  runTests()
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  beluga_manual_sync_tests()
     .then(() => {
       console.log("✅ Beluga manual sync test suite completed successfully")
       process.exit(0)

package/src/tests/api_tests/beluga_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 { BELUGA_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)
+
 // Beluga Trigger Refill journey action tests (CU-86e2gbv7y).
 //
 // Validator-acceptance only: verifies that automation steps configured with the new
@@ -18,9 +19,65 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
 // invalid shapes are rejected. No live Beluga call is made — external/triggerRefill requires
 // sandbox credentials, and the process endpoint's guard branches (missing integration, missing
 // preferences) mirror the already-tested belugaAutoRx/belugaUpdateVisit handlers.
-export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Beluga Trigger Refill Journey Action Tests")
+//
+// Runs on its own provisioned tenant, which is what makes the cross-patient guard reliable: a fresh
+// tenant never holds a Beluga integration, so the placeholder below is always created and the guard
+// is always exercised. On the shared fixture this suite probed the org's integrations first and
+// printed "Skipping" when it could not get one — a skip reports green without asserting anything.
+export const beluga_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
   let formId: string | undefined
   const stepIds: string[] = []
@@ -33,6 +90,13 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
   let createdBelugaIntegrationId: string | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Beluga trigger refill ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     const journey = await sdk.api.journeys.createOne({ title: 'Beluga Trigger Refill Test Journey' })
     journeyId = journey.id
 
@@ -40,7 +104,7 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
     formId = form.id
 
     // Inline med IDs variant
-    await async_test(
+    await expect_result(
       "belugaTriggerRefill step accepted (inline medIds)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -54,11 +118,11 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
           },
         },
       }).then(s => { stepIds.push(s.id); return s }),
-      passOnAnyResult,
+      () => true, // passOnAnyResult
     )
 
     // Organization mapping variant
-    await async_test(
+    await expect_result(
       "belugaTriggerRefill step accepted (organization mapping)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -71,11 +135,11 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
           },
         },
       }).then(s => { stepIds.push(s.id); return s }),
-      passOnAnyResult,
+      () => true, // passOnAnyResult
     )
 
     // Invalid formId (not a mongo id) rejected
-    await async_test(
+    await expect_rejected(
       "belugaTriggerRefill step rejected (invalid formId)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -88,11 +152,10 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
           },
         } as any,
       }),
-      { shouldError: true, onError: () => true },
     )
 
     // Missing formId rejected
-    await async_test(
+    await expect_rejected(
       "belugaTriggerRefill step rejected (missing formId)",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -104,12 +167,11 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
           },
         } as any,
       }),
-      { shouldError: true, onError: () => true },
     )
 
     // Unexpected fields in a patient preference are stripped by objectValidator, not rejected —
     // assert they never reach the stored config (the step itself is accepted)
-    await async_test(
+    await expect_result(
       "belugaTriggerRefill step strips unexpected patientPreferences field",
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
@@ -122,11 +184,9 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
           },
         } as any,
       }).then(s => { stepIds.push(s.id); return s }),
-      {
-        onResult: s => {
-          const preference = (s.action.info as any).patientPreferences?.[0]
-          return preference?.medId === 'med-123' && preference?.pharmacyId === undefined
-        },
+      s => {
+        const preference = (s.action.info as any).patientPreferences?.[0]
+        return preference?.medId === 'med-123' && preference?.pharmacyId === undefined
       },
     )
 
@@ -135,7 +195,8 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
     // switchToRelatedContact step could point it at a DIFFERENT patient's form response and issue a
     // refill against their visit. This exercises the guard end-to-end: it returns BEFORE any live
     // Beluga call (no sandbox creds needed), but integration resolution precedes it in the handler,
-    // so a Beluga integration must exist — the test self-skips when one can't be created.
+    // so a Beluga integration must exist. This tenant is brand new and holds none, so the
+    // placeholder below is always created and the guard is always reached.
     const enduserA = await sdk.api.endusers.createOne({ fname: 'Beluga', lname: 'PatientA' })
     enduserAId = enduserA.id
     const enduserB = await sdk.api.endusers.createOne({ fname: 'Beluga', lname: 'PatientB' })
@@ -149,6 +210,8 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
     })
     otherPatientFormResponseId = otherResponse.id
 
+    // Kept from the shared-fixture version, and now expected never to be true: a freshly provisioned
+    // tenant holds no Beluga integration. If it ever is, provisioning changed.
     let belugaIntegrationAvailable = false
     try {
       const existing = await sdk.api.integrations.load_redacted({})
@@ -167,7 +230,13 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
         createdBelugaIntegrationId = created.id
         belugaIntegrationAvailable = true
       } catch (e) {
-        console.log("Could not create a Beluga integration; skipping cross-patient guard test:", e)
+        // A FAILED check, not a console "skip": a skip reports green without asserting anything,
+        // which is exactly what this migration exists to remove.
+        record(
+          'a placeholder Beluga integration can be created on a freshly provisioned tenant',
+          false,
+          `integration create failed, so the cross-patient guard below could not run: ${errorMessage(e)}`,
+        )
       }
     }
 
@@ -189,39 +258,55 @@ export const beluga_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: S
       } as any)
       automatedActionId = automatedAction.id
 
-      await async_test(
+      await expect_result(
         "belugaTriggerRefill rejects a form response owned by a different patient",
         () => sdk.api.automated_actions.process({ automatedActionId: automatedAction.id }),
-        { onResult: (r: any) => r?.success === false && /does not belong to this patient/i.test(r?.error || '') },
+        (r: any) => r?.success === false && /does not belong to this patient/i.test(r?.error || ''),
       )
     } else {
-      console.log("⏭️  Skipping belugaTriggerRefill cross-patient guard test (no Beluga integration available)")
+      // Under the guard's OWN label, so the check table carries the same row set on every run —
+      // a missing row reads as "this was never written", which is the opposite of what happened.
+      record(
+        "belugaTriggerRefill rejects a form response owned by a different patient",
+        false,
+        'no Beluga integration was available on this tenant, so the cross-patient guard could not run',
+      )
     }
   } finally {
-    if (automatedActionId) await sdk.api.automated_actions.deleteOne(automatedActionId).catch(console.error)
-    if (otherPatientFormResponseId) await sdk.api.form_responses.deleteOne(otherPatientFormResponseId).catch(console.error)
-    if (enduserAId) await sdk.api.endusers.deleteOne(enduserAId).catch(console.error)
-    if (enduserBId) await sdk.api.endusers.deleteOne(enduserBId).catch(console.error)
-    if (createdBelugaIntegrationId) await sdk.api.integrations.deleteOne(createdBelugaIntegrationId).catch(console.error)
-    for (const id of stepIds) {
-      await sdk.api.automation_steps.deleteOne(id).catch(console.error)
+    if (tenant) {
+      const { sdk } = tenant
+      if (automatedActionId) await sdk.api.automated_actions.deleteOne(automatedActionId).catch(console.error)
+      if (otherPatientFormResponseId) await sdk.api.form_responses.deleteOne(otherPatientFormResponseId).catch(console.error)
+      if (enduserAId) await sdk.api.endusers.deleteOne(enduserAId).catch(console.error)
+      if (enduserBId) await sdk.api.endusers.deleteOne(enduserBId).catch(console.error)
+      if (createdBelugaIntegrationId) await sdk.api.integrations.deleteOne(createdBelugaIntegrationId).catch(console.error)
+      for (const id of stepIds) {
+        await sdk.api.automation_steps.deleteOne(id).catch(console.error)
+      }
+      if (formId) await sdk.api.forms.deleteOne(formId).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 (formId) await sdk.api.forms.deleteOne(formId).catch(console.error)
-    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 beluga_trigger_refill_tests = async () => {
+  assert_checks('Beluga trigger refill', await beluga_trigger_refill_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await beluga_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: 'Beluga trigger refill',
+  run: beluga_trigger_refill_checks,
+}
 
-  runTests()
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  beluga_trigger_refill_tests()
     .then(() => {
       console.log("✅ Beluga trigger refill test suite completed successfully")
       process.exit(0)