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

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

@@ -1,126 +1,161 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-// Main test function for tickets bulk_assign addToCareTeam flag
-export const tickets_bulk_assign_care_team_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Tickets Bulk Assign (addToCareTeam) Tests")
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
-  // Throwaway user to act as the new ticket owner
-  const owner = await sdk.api.users.createOne({
-    email: `test-bulk-assign-owner-${Date.now()}@test.com`,
-    fname: 'BulkAssign',
-    lname: 'Owner',
-    verifiedEmail: true,
-  })
+// Coverage for the tickets bulk_assign `addToCareTeam` flag: omitted and false leave the ticket
+// enduser's care team untouched, true adds the new owner to every ticket enduser's care team
+// (including tickets flagged skipCareTeamAssignment — the explicit flag wins), tolerates a ticket
+// with no enduser, and is idempotent when the owner is already on the care team.
+export const tickets_bulk_assign_care_team_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  const enduser1 = await sdk.api.endusers.createOne({ fname: 'BulkAssign', lname: 'PatientOne' })
-  const enduser2 = await sdk.api.endusers.createOne({ fname: 'BulkAssign', lname: 'PatientTwo' })
-
-  // Tickets are created without an owner so the on-create care team side effect doesn't run
-  const ticket1 = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 1', enduserId: enduser1.id })
-  const ticket2 = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 2', enduserId: enduser1.id })
-  const ticket3 = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 3', enduserId: enduser2.id, skipCareTeamAssignment: true })
-  const ticketNoEnduser = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 4' })
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    // Default behavior (flag omitted): owner set, care team untouched
-    await async_test(
-      "bulk_assign: assigns owner without flag",
-      () => sdk.api.tickets.bulk_assign({ ids: [ticket1.id], userId: owner.id }),
-      { onResult: () => true }
-    )
-    await async_test(
-      "bulk_assign: owner set on ticket (no flag)",
-      () => sdk.api.tickets.getOne(ticket1.id),
-      { onResult: t => t.owner === owner.id }
-    )
-    await async_test(
-      "bulk_assign: care team unchanged without flag",
-      () => sdk.api.endusers.getOne(enduser1.id),
-      { onResult: e => !e.assignedTo?.includes(owner.id) }
-    )
-
-    // addToCareTeam: false behaves like omitted
-    await async_test(
-      "bulk_assign: addToCareTeam false leaves care team unchanged",
-      async () => {
-        await sdk.api.tickets.bulk_assign({ ids: [ticket1.id], userId: owner.id, addToCareTeam: false })
-        return sdk.api.endusers.getOne(enduser1.id)
-      },
-      { onResult: e => !e.assignedTo?.includes(owner.id) }
-    )
-
-    // addToCareTeam: true adds owner to each ticket's enduser care team,
-    // including tickets flagged skipCareTeamAssignment (explicit flag wins),
-    // and tolerates tickets with no enduser
-    await async_test(
-      "bulk_assign: addToCareTeam true assigns owner and updates care teams",
-      () => sdk.api.tickets.bulk_assign({
+    tenant = await setup_isolated_tenant({
+      name: `BulkAssignCareTeam ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    // Throwaway user to act as the new ticket owner. Only the `dontsend-` prefix on the
+    // @tellescope.com domain suppresses outbound mail, so the address must keep both.
+    const owner = await sdk.api.users.createOne({
+      email: `dontsend-bulk-assign-care-team-${RAND()}@tellescope.com`,
+      fname: 'BulkAssign',
+      lname: 'Owner',
+      verifiedEmail: true,
+    })
+
+    const enduser1 = await sdk.api.endusers.createOne({ fname: 'BulkAssign', lname: 'PatientOne' })
+    const enduser2 = await sdk.api.endusers.createOne({ fname: 'BulkAssign', lname: 'PatientTwo' })
+
+    // Tickets are created without an owner so the on-create care team side effect doesn't run
+    const ticket1 = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 1', enduserId: enduser1.id })
+    const ticket2 = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 2', enduserId: enduser1.id })
+    const ticket3 = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 3', enduserId: enduser2.id, skipCareTeamAssignment: true })
+    const ticketNoEnduser = await sdk.api.tickets.createOne({ title: 'Bulk Assign Test 4' })
+
+    try {
+      /* ===== A: default behavior (flag omitted): owner set, care team untouched ===== */
+
+      const noFlagResult = await sdk.api.tickets.bulk_assign({ ids: [ticket1.id], userId: owner.id })
+      const afterNoFlag = await sdk.api.tickets.getOne(ticket1.id)
+      record(
+        'bulk_assign: owner set on ticket without the flag',
+        afterNoFlag.owner === owner.id,
+        `assigned=${noFlagResult.assigned} owner=${afterNoFlag.owner ? afterNoFlag.owner : '(none)'} (want ${owner.id})`,
+      )
+
+      const careTeamNoFlag = await sdk.api.endusers.getOne(enduser1.id)
+      record(
+        'bulk_assign: care team unchanged without the flag',
+        !careTeamNoFlag.assignedTo?.includes(owner.id),
+        `assignedTo=${JSON.stringify(careTeamNoFlag.assignedTo ?? [])} (must NOT contain ${owner.id})`,
+      )
+
+      /* ===== B: addToCareTeam: false behaves like omitted ===== */
+
+      await sdk.api.tickets.bulk_assign({ ids: [ticket1.id], userId: owner.id, addToCareTeam: false })
+      const careTeamFalse = await sdk.api.endusers.getOne(enduser1.id)
+      record(
+        'bulk_assign: addToCareTeam false leaves care team unchanged',
+        !careTeamFalse.assignedTo?.includes(owner.id),
+        `assignedTo=${JSON.stringify(careTeamFalse.assignedTo ?? [])} (must NOT contain ${owner.id})`,
+      )
+
+      /* ===== C: addToCareTeam: true adds the owner to each ticket enduser's care team,
+           including tickets flagged skipCareTeamAssignment, and tolerates a ticket with no enduser ===== */
+
+      const flagResult = await sdk.api.tickets.bulk_assign({
         ids: [ticket1.id, ticket2.id, ticket3.id, ticketNoEnduser.id],
         userId: owner.id,
         addToCareTeam: true,
-      }),
-      { onResult: () => true }
-    )
-    await async_test(
-      "bulk_assign: owner added to care team (enduser1)",
-      () => sdk.api.endusers.getOne(enduser1.id),
-      { onResult: e => !!e.assignedTo?.includes(owner.id) }
-    )
-    await async_test(
-      "bulk_assign: owner added to care team despite skipCareTeamAssignment (enduser2)",
-      () => sdk.api.endusers.getOne(enduser2.id),
-      { onResult: e => !!e.assignedTo?.includes(owner.id) }
-    )
-    await async_test(
-      "bulk_assign: ticket without enduser still assigned",
-      () => sdk.api.tickets.getOne(ticketNoEnduser.id),
-      { onResult: t => t.owner === owner.id }
-    )
-
-    // Idempotent when owner already on care team
-    await async_test(
-      "bulk_assign: addToCareTeam is idempotent",
-      async () => {
-        await sdk.api.tickets.bulk_assign({ ids: [ticket1.id], userId: owner.id, addToCareTeam: true })
-        return sdk.api.endusers.getOne(enduser1.id)
-      },
-      { onResult: e => e.assignedTo?.filter(id => id === owner.id).length === 1 }
-    )
+      })
+      record(
+        'bulk_assign: addToCareTeam true assigns every ticket in the call',
+        flagResult.assigned === 4,
+        `assigned=${flagResult.assigned} skipped=${flagResult.skipped} (want 4 assigned)`,
+      )
+
+      const careTeam1 = await sdk.api.endusers.getOne(enduser1.id)
+      record(
+        'bulk_assign: owner added to care team (enduser1)',
+        !!careTeam1.assignedTo?.includes(owner.id),
+        `assignedTo=${JSON.stringify(careTeam1.assignedTo ?? [])} (want it to contain ${owner.id})`,
+      )
+
+      const careTeam2 = await sdk.api.endusers.getOne(enduser2.id)
+      record(
+        'bulk_assign: owner added to care team despite skipCareTeamAssignment (enduser2)',
+        !!careTeam2.assignedTo?.includes(owner.id),
+        `assignedTo=${JSON.stringify(careTeam2.assignedTo ?? [])} (want it to contain ${owner.id} — the explicit flag wins)`,
+      )
+
+      const afterNoEnduser = await sdk.api.tickets.getOne(ticketNoEnduser.id)
+      record(
+        'bulk_assign: ticket without enduser still assigned',
+        afterNoEnduser.owner === owner.id,
+        `owner=${afterNoEnduser.owner ? afterNoEnduser.owner : '(none)'} (want ${owner.id})`,
+      )
+
+      /* ===== D: idempotent when the owner is already on the care team ===== */
+
+      await sdk.api.tickets.bulk_assign({ ids: [ticket1.id], userId: owner.id, addToCareTeam: true })
+      const careTeamRepeat = await sdk.api.endusers.getOne(enduser1.id)
+      const occurrences = careTeamRepeat.assignedTo?.filter(id => id === owner.id).length
+      record(
+        'bulk_assign: addToCareTeam is idempotent',
+        occurrences === 1,
+        `assignedTo=${JSON.stringify(careTeamRepeat.assignedTo ?? [])} contains ${owner.id} ${occurrences ?? 0} time(s) (want 1)`,
+      )
+    } finally {
+      // per-record cleanup is kept even though teardown subsumes it, so the body stays runnable
+      // against any tenant
+      await Promise.all([
+        sdk.api.tickets.deleteOne(ticket1.id).catch(console.error),
+        sdk.api.tickets.deleteOne(ticket2.id).catch(console.error),
+        sdk.api.tickets.deleteOne(ticket3.id).catch(console.error),
+        sdk.api.tickets.deleteOne(ticketNoEnduser.id).catch(console.error),
+        sdk.api.endusers.deleteOne(enduser1.id).catch(console.error),
+        sdk.api.endusers.deleteOne(enduser2.id).catch(console.error),
+        sdk.api.users.deleteOne(owner.id).catch(console.error),
+      ])
+    }
   } finally {
-    // Cleanup
-    await Promise.all([
-      sdk.api.tickets.deleteOne(ticket1.id).catch(console.error),
-      sdk.api.tickets.deleteOne(ticket2.id).catch(console.error),
-      sdk.api.tickets.deleteOne(ticket3.id).catch(console.error),
-      sdk.api.tickets.deleteOne(ticketNoEnduser.id).catch(console.error),
-      sdk.api.endusers.deleteOne(enduser1.id).catch(console.error),
-      sdk.api.endusers.deleteOne(enduser2.id).catch(console.error),
-      sdk.api.users.deleteOne(owner.id).catch(console.error),
-    ])
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+    if (tenant) { try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) } }
   }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const tickets_bulk_assign_care_team_tests = async () => {
+  assert_checks('Tickets bulk assign care team', await tickets_bulk_assign_care_team_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Tickets bulk assign care team',
+  run: tickets_bulk_assign_care_team_checks,
 }
 
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
-
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await tickets_bulk_assign_care_team_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  tickets_bulk_assign_care_team_tests()
     .then(() => {
       console.log("✅ Tickets bulk assign care team test suite completed successfully")
       process.exit(0)

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

@@ -1,14 +1,16 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  assert,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  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)
+
 // Modular test for the translations framework.
 // Validates that a model's `translations` field (nested { field: { language: text } }) is accepted by
 // schema validation, persists, and accumulates multiple languages (uses phone_calls as the MVP model).
@@ -17,61 +19,82 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
 // That path consumes AI credits and belongs in an eval, not a regularly-run test. The endpoint itself is
 // already covered by the AI Summary feature, and the translation-specific logic (the system-prompt
 // builder in @tellescope/utilities) is a pure function verified at compile time.
-export const translations_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Translations Framework Tests")
+export const translations_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  const enduser = await sdk.api.endusers.createOne({ fname: 'Translation', lname: 'Tester' })
-  let callId: string | undefined
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    const call = await sdk.api.phone_calls.createOne({
-      enduserId: enduser.id,
-      inbound: true,
-      userId: sdk.userInfo.id,
-      transcription: 'Hola, por favor devuélvame la llamada cuando pueda.',
+    tenant = await setup_isolated_tenant({
+      name: `Translations ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
     })
-    callId = call.id
+    const { sdk } = tenant
+
+    const enduser = await sdk.api.endusers.createOne({ fname: 'Translation', lname: 'Tester' })
+    let callId: string | undefined
+
+    try {
+      const call = await sdk.api.phone_calls.createOne({
+        enduserId: enduser.id,
+        inbound: true,
+        userId: sdk.userInfo.id,
+        transcription: 'Hola, por favor devuélvame la llamada cuando pueda.',
+      })
+      callId = call.id
 
-    // --- 1. translations field accepted + persisted ---
-    const translations = { transcription: { en: 'Hi, please call me back when you can.' } }
-    await sdk.api.phone_calls.updateOne(call.id, { translations }, { replaceObjectFields: true })
+      // --- 1. translations field accepted + persisted ---
+      const translations = { transcription: { en: 'Hi, please call me back when you can.' } }
+      await sdk.api.phone_calls.updateOne(call.id, { translations }, { replaceObjectFields: true })
 
-    const updated = await sdk.api.phone_calls.getOne(call.id)
-    assert(
-      updated.translations?.transcription?.en === translations.transcription.en,
-      `translations not persisted: ${JSON.stringify(updated.translations)}`,
-      'translations field persisted correctly',
-    )
+      const updated = await sdk.api.phone_calls.getOne(call.id)
+      record(
+        'translations field persisted correctly',
+        updated.translations?.transcription?.en === translations.transcription.en,
+        `translations=${updated.translations ? JSON.stringify(updated.translations) : '(none)'}`
+        + ` (want transcription.en=${JSON.stringify(translations.transcription.en)})`,
+      )
 
-    // add a second language and confirm accumulation (full merged object written by convention)
-    const merged = {
-      ...updated.translations,
-      transcription: { ...updated.translations?.transcription, es: 'Hola de nuevo.' },
+      // add a second language and confirm accumulation (full merged object written by convention)
+      const merged = {
+        ...updated.translations,
+        transcription: { ...updated.translations?.transcription, es: 'Hola de nuevo.' },
+      }
+      await sdk.api.phone_calls.updateOne(call.id, { translations: merged }, { replaceObjectFields: true })
+      const updated2 = await sdk.api.phone_calls.getOne(call.id)
+      record(
+        'multiple language translations accumulate under one field',
+        !!updated2.translations?.transcription?.en && !!updated2.translations?.transcription?.es,
+        `translations=${updated2.translations ? JSON.stringify(updated2.translations) : '(none)'} (want both transcription.en and transcription.es)`,
+      )
+    } finally {
+      // per-record cleanup is kept even though teardown subsumes it, so the body stays runnable
+      // against any tenant
+      if (callId) await sdk.api.phone_calls.deleteOne(callId).catch(() => {})
+      await sdk.api.endusers.deleteOne(enduser.id).catch(() => {})
     }
-    await sdk.api.phone_calls.updateOne(call.id, { translations: merged }, { replaceObjectFields: true })
-    const updated2 = await sdk.api.phone_calls.getOne(call.id)
-    assert(
-      !!updated2.translations?.transcription?.en && !!updated2.translations?.transcription?.es,
-      `translations did not accumulate: ${JSON.stringify(updated2.translations)}`,
-      'multiple language translations accumulate under one field',
-    )
   } finally {
-    if (callId) await sdk.api.phone_calls.deleteOne(callId).catch(() => {})
-    await sdk.api.endusers.deleteOne(enduser.id).catch(() => {})
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+    if (tenant) { try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) } }
   }
+
+  return checks
 }
 
-// Allow running this test file independently
-if (require.main === module) {
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const translations_tests = async () => {
+  assert_checks('Translations', await translations_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await translations_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Translations', run: translations_checks }
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  translations_tests()
     .then(() => {
       console.log("✅ Translations test suite completed successfully")
       process.exit(0)