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

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

@@ -0,0 +1,314 @@
+require('source-map-support').install();
+
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Coverage for coupling a ticket's Stage to real archival (CU-86e3hhavw).
+ *
+ * Stage: Archived used to be cosmetic — only the Archive Ticket button set archiveReason + closedAt
+ * + closedBy, and only that real archival stops a Journey advancing to its next step
+ * (handleTicketClosed skips a ticket whose archiveReason is set). Customers staged tickets Archived
+ * and expected them to be archived. The generic update route in api/modules/routing.ts now folds the
+ * archival into `updates` before the `$set`, so the archived state is part of the same write and is
+ * visible to the PATCH response, the webhooks and every v2 side effect.
+ *
+ * A: changing the stage to Archived archives the ticket, and says so in the PATCH response.
+ * B: changing the stage off Archived un-archives it (the Un-Archive button's payload).
+ * C: an already-Completed ticket keeps the closedAt it was actually closed at.
+ * D: repeating the stage change does not rewrite the reason or the timestamp.
+ * E: an explicit archiveReason in the same payload is not overwritten.
+ * F: with organization.settings.tickets.allowArchival off (the default, and so what every existing
+ *    organization sees until it opts in), Stage: Archived behaves exactly as it did before.
+ * G: a queued ticket archives and stays in its queue — parity with the Archive Ticket button.
+ * H: a payload that re-states closedAt (the Edit Ticket form, or any full-record PATCH) is not a
+ *    move off Archived, while the Stage select's stage-only payload still is.
+ */
+
+/** The queue count is maintained by asynchronous side effects, so reads of it poll. */
+const poll_for = async <T,>(get: () => Promise<T>, done: (v: T) => boolean, attempts=20): Promise<T> => {
+  let value = await get()
+  for (let i = 0; i < attempts && !done(value); i++) {
+    await new Promise(resolve => setTimeout(resolve, 250))
+    value = await get()
+  }
+  return value
+}
+
+export const ticket_stage_archive_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+  let noArchivalTenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  try {
+    ;[tenant, noArchivalTenant] = await Promise.all([
+      setup_isolated_tenant({ name: `StageArchive ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0 }),
+      setup_isolated_tenant({ name: `StageArchive off ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0 }),
+    ])
+
+    const { sdk } = tenant
+    const adminId = tenant.users[0].id
+
+    // archival is off by default — this tenant opts in, noArchivalTenant deliberately does not
+    await sdk.api.organizations.updateOne(sdk.userInfo.businessId, {
+      settings: { tickets: { allowArchival: true } },
+    } as any)
+
+    const settings = await sdk.api.organizations.getOne(sdk.userInfo.businessId)
+    record(
+      'setup: allowArchival is enabled for the primary tenant',
+      settings.settings?.tickets?.allowArchival === true,
+      `allowArchival=${JSON.stringify(settings.settings?.tickets?.allowArchival)}`,
+    )
+
+    /* ===== A: Stage -> Archived archives the ticket ===== */
+
+    const ticket = await sdk.api.tickets.createOne({ title: `Stage archive ${RAND()}` })
+    record(
+      'setup: a new ticket is open and unarchived',
+      !ticket.closedAt && !ticket.archiveReason,
+      `closedAt=${JSON.stringify(ticket.closedAt)} archiveReason=${JSON.stringify(ticket.archiveReason)}`,
+    )
+
+    const archivedResponse = await sdk.api.tickets.updateOne(ticket.id, { stage: 'Archived' })
+    record(
+      'A1: the PATCH response already reflects the archival',
+      archivedResponse.archiveReason === 'Stage set to Archived'
+        && !!archivedResponse.closedAt
+        && archivedResponse.closedBy === adminId,
+      `response archiveReason=${JSON.stringify(archivedResponse.archiveReason)}`
+      + ` closedAt=${JSON.stringify(archivedResponse.closedAt)} closedBy=${JSON.stringify(archivedResponse.closedBy)}`
+      + ` — a side effect instead of a folded update would leave these unset here, and would land after`
+      + ` the Journey next-step check`,
+    )
+
+    const archived = await sdk.api.tickets.getOne(ticket.id)
+    record(
+      'A2: the stored ticket is archived: reason, closedAt and closedBy all set',
+      archived.stage === 'Archived'
+        && archived.archiveReason === 'Stage set to Archived'
+        && !!archived.closedAt
+        && archived.closedBy === adminId,
+      `stage=${JSON.stringify(archived.stage)} archiveReason=${JSON.stringify(archived.archiveReason)}`
+      + ` closedAt=${JSON.stringify(archived.closedAt)} closedBy=${JSON.stringify(archived.closedBy)} (want closedBy=${adminId})`,
+    )
+
+    /* ===== B: Stage -> anything else un-archives ===== */
+
+    const unarchived = await sdk.api.tickets.updateOne(ticket.id, { stage: 'In Progress' })
+    record(
+      'B1: moving off Archived clears the reason, closedAt and closedBy',
+      unarchived.stage === 'In Progress'
+        && !unarchived.archiveReason
+        && !unarchived.closedAt
+        && !unarchived.closedBy,
+      `stage=${JSON.stringify(unarchived.stage)} archiveReason=${JSON.stringify(unarchived.archiveReason)}`
+      + ` closedAt=${JSON.stringify(unarchived.closedAt)} closedBy=${JSON.stringify(unarchived.closedBy)}`,
+    )
+
+    const unarchivedStored = await sdk.api.tickets.getOne(ticket.id)
+    record(
+      'B2: the un-archival is stored, not only echoed',
+      !unarchivedStored.archiveReason && !unarchivedStored.closedAt && !unarchivedStored.closedBy,
+      `archiveReason=${JSON.stringify(unarchivedStored.archiveReason)}`
+      + ` closedAt=${JSON.stringify(unarchivedStored.closedAt)} closedBy=${JSON.stringify(unarchivedStored.closedBy)}`
+      + ` — null/undefined would be dropped from the update rather than written`,
+    )
+
+    // a stage change on a ticket that was never archived must not touch anything else
+    const neverArchived = await sdk.api.tickets.createOne({ title: `Stage plain ${RAND()}` })
+    const plainStage = await sdk.api.tickets.updateOne(neverArchived.id, { stage: 'Blocked' })
+    record(
+      'B3: a stage change on an open, never-archived ticket changes only the stage',
+      plainStage.stage === 'Blocked' && !plainStage.closedAt && !plainStage.archiveReason,
+      `stage=${JSON.stringify(plainStage.stage)} closedAt=${JSON.stringify(plainStage.closedAt)}`
+      + ` archiveReason=${JSON.stringify(plainStage.archiveReason)}`,
+    )
+
+    /* ===== C: an already-Completed ticket keeps its closedAt ===== */
+
+    const completedAt = new Date(Date.now() - 1000 * 60 * 60 * 24 * 7) // a week ago
+    const completed = await sdk.api.tickets.createOne({ title: `Stage archive completed ${RAND()}` })
+    await sdk.api.tickets.updateOne(completed.id, { closedAt: completedAt, closedBy: adminId })
+
+    const completedThenArchived = await sdk.api.tickets.updateOne(completed.id, { stage: 'Archived' })
+    const storedClosedAt = new Date(completedThenArchived.closedAt as any).getTime()
+    record(
+      'C1: archiving an already-Completed ticket preserves its original closedAt',
+      completedThenArchived.archiveReason === 'Stage set to Archived'
+        && storedClosedAt === completedAt.getTime(),
+      `closedAt=${JSON.stringify(completedThenArchived.closedAt)} (want ${completedAt.toISOString()});`
+      + ` archiveReason=${JSON.stringify(completedThenArchived.archiveReason)}`
+      + ` — overwriting it would move the Closed date to today`,
+    )
+
+    /* ===== D: repeating the stage change is a no-op ===== */
+
+    const reArchived = await sdk.api.tickets.updateOne(completed.id, { stage: 'Archived' })
+    record(
+      'D1: setting the stage to Archived a second time rewrites neither the reason nor closedAt',
+      reArchived.archiveReason === 'Stage set to Archived'
+        && new Date(reArchived.closedAt as any).getTime() === completedAt.getTime(),
+      `archiveReason=${JSON.stringify(reArchived.archiveReason)} closedAt=${JSON.stringify(reArchived.closedAt)}`
+      + ` (want ${completedAt.toISOString()})`,
+    )
+
+    /* ===== E: an explicit archiveReason in the same payload wins ===== */
+
+    const explicit = await sdk.api.tickets.createOne({ title: `Stage archive explicit ${RAND()}` })
+    const explicitArchived = await sdk.api.tickets.updateOne(explicit.id, {
+      stage: 'Archived', archiveReason: 'Duplicate of another ticket',
+    })
+    record(
+      'E1: an archiveReason supplied with the stage is not replaced by the default',
+      explicitArchived.archiveReason === 'Duplicate of another ticket' && !!explicitArchived.closedAt,
+      `archiveReason=${JSON.stringify(explicitArchived.archiveReason)} closedAt=${JSON.stringify(explicitArchived.closedAt)}`,
+    )
+
+    /* ===== H: a full-record PATCH is not a move off Archived ===== */
+
+    // The Edit Ticket form submits every field of the record it loaded, including `stage` and
+    // `closedAt`, whose inputs are hidden for a closed ticket. On a ticket archived from the Archive
+    // Ticket button — which never writes stage, so the stage is still 'In Progress' or the like —
+    // that payload must not be read as a stage change off Archived. The same goes for any API
+    // consumer that PATCHes a whole ticket record back.
+    const buttonArchived = await sdk.api.tickets.createOne({
+      title: `Stage archive button ${RAND()}`, stage: 'In Progress',
+    })
+    const buttonClosedAt = new Date(Date.now() - 1000 * 60 * 60) // an hour ago
+    await sdk.api.tickets.updateOne(buttonArchived.id, {
+      archiveReason: 'Archived from the button', closedAt: buttonClosedAt, closedBy: adminId,
+    })
+
+    const editedTitle = `Stage archive button edited ${RAND()}`
+    const edited = await sdk.api.tickets.updateOne(buttonArchived.id, {
+      title: editedTitle, stage: 'In Progress', closedAt: buttonClosedAt, // exactly the editor's payload
+    })
+    record(
+      'H1: editing an archived ticket (full record, stage unchanged) does not un-archive it',
+      edited.title === editedTitle
+        && edited.archiveReason === 'Archived from the button'
+        && new Date(edited.closedAt as any).getTime() === buttonClosedAt.getTime()
+        && edited.closedBy === adminId,
+      `title=${JSON.stringify(edited.title)} archiveReason=${JSON.stringify(edited.archiveReason)}`
+      + ` closedAt=${JSON.stringify(edited.closedAt)} (want ${buttonClosedAt.toISOString()}) closedBy=${JSON.stringify(edited.closedBy)}`
+      + ` — a bare stage comparison here would re-open the ticket and wipe its archive reason`,
+    )
+
+    // but the Stage column's select — which sends the stage on its own — still un-archives it
+    const unarchivedFromColumn = await sdk.api.tickets.updateOne(buttonArchived.id, { stage: 'Blocked' })
+    record(
+      'H2: the Stage select still un-archives a button-archived ticket (stage alone, no closedAt)',
+      unarchivedFromColumn.stage === 'Blocked'
+        && !unarchivedFromColumn.archiveReason
+        && !unarchivedFromColumn.closedAt
+        && !unarchivedFromColumn.closedBy,
+      `stage=${JSON.stringify(unarchivedFromColumn.stage)} archiveReason=${JSON.stringify(unarchivedFromColumn.archiveReason)}`
+      + ` closedAt=${JSON.stringify(unarchivedFromColumn.closedAt)} closedBy=${JSON.stringify(unarchivedFromColumn.closedBy)}`,
+    )
+
+    /* ===== G: a queued ticket archives, and stays in its queue ===== */
+
+    // parity with the Archive Ticket button, which also leaves queue membership and the queue count
+    // alone — unlike close_ticket, which refuses outright for a queued ticket
+    const queue = await sdk.api.ticket_queues.createOne({ title: `Stage archive queue ${RAND()}`, userIds: [adminId] })
+    const queued = await sdk.api.tickets.createOne({ title: `Stage archive queued ${RAND()}`, queueId: queue.id })
+
+    // the queue count is maintained by asynchronous side effects
+    const countBefore = await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id).then(q => q.count ?? 0),
+      c => c === 1,
+    )
+
+    const queuedArchived = await sdk.api.tickets.updateOne(queued.id, { stage: 'Archived' })
+    // poll for a WRONG value rather than a right one: a decrement landing a moment later must fail
+    // this check, not slip past a single immediate read
+    const countAfter = await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id).then(q => q.count ?? 0),
+      c => c !== 1,
+      8, // ~2s of settling
+    )
+    record(
+      'G1: a queued ticket archives, keeping its queue membership and the queue count',
+      queuedArchived.archiveReason === 'Stage set to Archived'
+        && !!queuedArchived.closedAt
+        && queuedArchived.queueId === queue.id
+        && countBefore === 1 && countAfter === 1,
+      `archiveReason=${JSON.stringify(queuedArchived.archiveReason)} closedAt=${JSON.stringify(queuedArchived.closedAt)}`
+      + ` queueId=${JSON.stringify(queuedArchived.queueId)} (want ${queue.id}); count ${countBefore} -> ${countAfter} (want 1 -> 1)`,
+    )
+
+    /* ===== F: with archival disabled, nothing changes ===== */
+
+    const offSdk = noArchivalTenant.sdk
+    const offOrg = await offSdk.api.organizations.getOne(offSdk.userInfo.businessId)
+    record(
+      'F1: a newly provisioned organization has archival off',
+      !offOrg.settings?.tickets?.allowArchival,
+      `allowArchival=${JSON.stringify(offOrg.settings?.tickets?.allowArchival)} — the setting must stay opt-in`,
+    )
+
+    const offTicket = await offSdk.api.tickets.createOne({ title: `Stage archive off ${RAND()}` })
+    const offArchived = await offSdk.api.tickets.updateOne(offTicket.id, { stage: 'Archived' })
+    record(
+      'F2: without allowArchival, Stage: Archived stays cosmetic — the ticket is still open',
+      offArchived.stage === 'Archived' && !offArchived.closedAt && !offArchived.archiveReason && !offArchived.closedBy,
+      `stage=${JSON.stringify(offArchived.stage)} closedAt=${JSON.stringify(offArchived.closedAt)}`
+      + ` archiveReason=${JSON.stringify(offArchived.archiveReason)} closedBy=${JSON.stringify(offArchived.closedBy)}`,
+    )
+
+    // and an archived ticket in such an organization is not re-opened by a stage change either
+    const offArchivedByButton = await offSdk.api.tickets.createOne({ title: `Stage archive off button ${RAND()}` })
+    await offSdk.api.tickets.updateOne(offArchivedByButton.id, {
+      archiveReason: 'Archived by the button', closedAt: new Date(), closedBy: noArchivalTenant.users[0].id,
+    })
+    const offUnarchiveAttempt = await offSdk.api.tickets.updateOne(offArchivedByButton.id, { stage: 'In Progress' })
+    record(
+      'F3: without allowArchival, moving off Archived does not un-archive',
+      offUnarchiveAttempt.stage === 'In Progress'
+        && offUnarchiveAttempt.archiveReason === 'Archived by the button'
+        && !!offUnarchiveAttempt.closedAt,
+      `stage=${JSON.stringify(offUnarchiveAttempt.stage)} archiveReason=${JSON.stringify(offUnarchiveAttempt.archiveReason)}`
+      + ` closedAt=${JSON.stringify(offUnarchiveAttempt.closedAt)}`,
+    )
+  } finally {
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand these tenants.
+    for (const t of [tenant, noArchivalTenant]) {
+      if (t) { try { await t.teardown() } catch (e) { console.error('teardown failed', e) } }
+    }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const ticket_stage_archive_tests = async () => {
+  assert_checks('Ticket stage archival', await ticket_stage_archive_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Ticket stage archival', run: ticket_stage_archive_checks }
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  ticket_stage_archive_tests()
+    .then(() => {
+      console.log("✅ Ticket stage archival test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Ticket stage archival test suite failed:", error)
+      process.exit(1)
+    })
+}

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/tickets_bulk_assign_from_queue.test.ts

@@ -5,6 +5,7 @@ import {
   assert_checks,
   Check,
   setup_isolated_tenant,
+  IsolatedSuite,
 } from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
@@ -264,6 +265,9 @@ export const tickets_bulk_assign_from_queue_tests = async () => {
   assert_checks('Tickets bulk assign from queue', await tickets_bulk_assign_from_queue_checks())
 }
 
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Tickets bulk assign from queue', run: tickets_bulk_assign_from_queue_checks }
+
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)

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

@@ -302,11 +302,16 @@ export const totp_mfa_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkN
     // the already-configured email method must keep working (no lockout)
     await set_allowed_mfa_methods(['authenticator'])
 
-    await async_test(
-      'E5. grace: configured email challenge still works after restriction',
-      () => sdkNonAdmin.api.users.generate_MFA_challenge({ method: 'email' }),
-      { shouldError: false, onResult: () => true }
-    )
+    // a successful challenge really emails the code, so only send it to a do-not-send address
+    if (NON_ADMIN_EMAIL.startsWith('dontsend') && NON_ADMIN_EMAIL.endsWith('@tellescope.com')) {
+      await async_test(
+        'E5. grace: configured email challenge still works after restriction',
+        () => sdkNonAdmin.api.users.generate_MFA_challenge({ method: 'email' }),
+        { shouldError: false, onResult: () => true }
+      )
+    } else {
+      console.log('   E5 skipped: NON_ADMIN_EMAIL is not a dontsend address, a challenge would send a real email')
+    }
 
     // cleanup E: clear restriction + disable email
     await clear_allowed_mfa_methods()