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

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

@@ -1,11 +1,10 @@
 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,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
@@ -39,14 +38,25 @@ const postMDI = async (body: object, headers: Record<string, string> = {}) => {
  * Sandbox credentials (add_api_key_integration validates client creds via a live
  * MDI API call), so the end-to-end path is exercised in the Sandbox per the task
  * plan rather than here.
+ *
+ * DELIBERATELY PROVISIONS NO TENANT and holds no session. Every check below is a raw
+ * unauthenticated fetch against the public webhook URL: each one asserts that the endpoint
+ * rejects BEFORE it identifies a tenant, so there is nothing for a tenant to own. Enrolling in the
+ * isolated pool without calling setup_isolated_tenant is intentional, not an omission — do not
+ * "fix" it by provisioning one.
  */
-export const mdi_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("MD Integrations Webhooks Tests")
+export const mdi_webhooks_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
   // 1. Missing Authorization header -> 401 (tenant cannot be identified)
   {
     const { status } = await postMDI({ event_type: 'case_approved', case_id: 'mdi-case-test-1' })
-    assert(status === 401, `missing Authorization should 401 (got ${status})`, "MDI webhook rejects missing Authorization")
+    record(
+      'MDI webhook rejects missing Authorization',
+      status === 401,
+      `status=${status} (want 401)`,
+    )
   }
 
   // 2. Bogus Authorization token (no matching integration) -> 401
@@ -55,16 +65,25 @@ export const mdi_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, s
       { event_type: 'case_approved', case_id: 'mdi-case-test-1' },
       { 'Authorization': `Bearer not-a-real-mdi-token-${Date.now()}` },
     )
-    assert(status === 401, `unknown Authorization should 401 (got ${status})`, "MDI webhook rejects unknown Authorization")
+    record(
+      'MDI webhook rejects unknown Authorization',
+      status === 401,
+      `status=${status} (want 401)`,
+    )
   }
 
-  // 3. Missing event_type -> 400 (bad request), still before any tenant work
+  // 3. Missing event_type -> 400 (bad request), still before any tenant work.
+  //    400 OR 401 is accepted because the endpoint tests event_type before Authorization.
   {
     const { status } = await postMDI(
       { case_id: 'mdi-case-test-1' } as any,
       { 'Authorization': `Bearer not-a-real-mdi-token-${Date.now()}` },
     )
-    assert(status === 400 || status === 401, `missing event_type should 400/401 (got ${status})`, "MDI webhook rejects payload without event_type")
+    record(
+      'MDI webhook rejects payload without event_type',
+      status === 400 || status === 401,
+      `status=${status} (want 400 or 401 — event_type is checked before Authorization)`,
+    )
   }
 
   // 4. message_created with bogus auth -> still 401 (auth precedes patient lookup)
@@ -73,7 +92,11 @@ export const mdi_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, s
       { event_type: 'message_created', patient_id: 'mdi-patient-x', message_id: 'm-1', user_type: 'App\\Models\\User' },
       { 'Authorization': `Bearer not-a-real-mdi-token-${Date.now()}` },
     )
-    assert(status === 401, `message_created with bad auth should 401 (got ${status})`, "MDI webhook authenticates before patient lookup")
+    record(
+      'MDI webhook authenticates before patient lookup',
+      status === 401,
+      `status=${status} (want 401)`,
+    )
   }
 
   // 5. case_order_created / case_order_updated with bogus auth -> still 401.
@@ -82,21 +105,28 @@ export const mdi_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, s
       { event_type, case_id: 'mdi-case-test-1', case_order_id: 'mdi-order-test-1', order_status: 'ready' },
       { 'Authorization': `Bearer not-a-real-mdi-token-${Date.now()}` },
     )
-    assert(status === 401, `${event_type} with bad auth should 401 (got ${status})`, `MDI webhook authenticates before ${event_type} dispatch`)
+    record(
+      `MDI webhook authenticates before ${event_type} dispatch`,
+      status === 401,
+      `status=${status} (want 401)`,
+    )
   }
+
+  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 mdi_webhooks_tests = async () => {
+  assert_checks('MDI webhooks', await mdi_webhooks_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await mdi_webhooks_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'MDI webhooks', run: mdi_webhooks_checks }
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  mdi_webhooks_tests()
     .then(() => {
       console.log("✅ MD Integrations webhooks test suite completed successfully")
       process.exit(0)

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

@@ -1,43 +1,77 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import { 
-  log_header,
+import {
+  poll_for_results,
   wait,
 } from "@tellescope/testing"
-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)
 
 /**
- * Tests for the "Assign to Incoming Message" trigger action
- * Verifies assignment works for all incoming message types: Email, SMS, and ChatRoom
+ * Tests for the "Assign to Incoming Message" trigger action.
+ * Verifies assignment works for all incoming message types: Email, SMS, and ChatRoom.
+ *
+ * Runs on its own provisioned tenant, which is not optional here: the three triggers this installs
+ * are filtered by channel and nothing else, so on the shared organization every inbound email, SMS
+ * and chat created by any concurrently running suite was auto-assigned to this suite's user for as
+ * long as this suite ran. It never calls `sdk.reset_db()`, which clears throttle namespaces shared
+ * with other suites.
+ *
+ * Each case uses its own patient — triggers are throttled to one fire per trigger per enduser per
+ * minute — and the `wait` after each write is the trigger-processing barrier. The three positive
+ * cases then poll, which returns immediately once the assignment is visible, so a slow API reports
+ * a real failure rather than a timing one. The outbound-exclusion case is read once: polling a
+ * "must not happen" check only delays it.
+ *
+ * No records are deleted individually; the tenant teardown in the `finally` removes every record it
+ * owns, and nothing outside the tenant can see them in the meantime.
  */
+export const message_assignment_trigger_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-export const message_assignment_trigger_tests = async ({ sdk }: { sdk: Session }) => {
-  log_header("Message Assignment Trigger Tests")
-
-  // Create different patients for each test to avoid rate limiting
-  const [emailPatient, smsPatient, chatPatient] = (await sdk.api.endusers.createSome([
-    { fname: 'Email', lname: 'Patient', assignedTo: [sdk.userInfo.id] }, // Assign to care team
-    { fname: 'SMS', lname: 'Patient', assignedTo: [sdk.userInfo.id] },   // Assign to care team
-    { fname: 'Chat', lname: 'Patient', assignedTo: [sdk.userInfo.id] },  // Assign to care team
-  ])).created
-
-  console.log(`Created test patients:`)
-  console.log(`  Email: ${emailPatient.id}`)
-  console.log(`  SMS: ${smsPatient.id}`)
-  console.log(`  Chat: ${chatPatient.id}`)
-
-  let emailTrigger: any
-  let smsTrigger: any
-  let chatTrigger: any
-  let emailMessage: any
-  let smsMessage: any
-  let chatRoom: any
-  let chatMessage: any
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Message assignment trigger ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    // emails.createOne is registered `requiresInboxConfiguration`, which reads username/orgEmail off
+    // the JWT, and a provisioned user has neither — the Email case would 400 before any trigger ran.
+    // (The shared fixture's user was hand-seeded with them, so this step is new to the isolated run.)
+    // configure_inbox is a plain POST: it mints a token but does not install it, hence the refresh.
+    // username is unique per organization; a fresh random one keeps back-to-back runs independent.
+    await sdk.api.users.configure_inbox({ username: `inbox${RAND()}`, fname: 'Assignment', lname: 'Staff' })
+    await sdk.refresh_session()
+
+    // Create different patients for each test to avoid rate limiting
+    const [emailPatient, smsPatient, chatPatient, outboundPatient] = (await sdk.api.endusers.createSome([
+      { fname: 'Email', lname: 'Patient', assignedTo: [sdk.userInfo.id] },    // Assign to care team
+      { fname: 'SMS', lname: 'Patient', assignedTo: [sdk.userInfo.id] },      // Assign to care team
+      { fname: 'Chat', lname: 'Patient', assignedTo: [sdk.userInfo.id] },     // Assign to care team
+      { fname: 'Outbound', lname: 'Patient', assignedTo: [sdk.userInfo.id] }, // Assign to care team
+    ])).created
+
+    console.log(`Created test patients:`)
+    console.log(`  Email: ${emailPatient.id}`)
+    console.log(`  SMS: ${smsPatient.id}`)
+    console.log(`  Chat: ${chatPatient.id}`)
+    console.log(`  Outbound: ${outboundPatient.id}`)
+
     // Create triggers using the "Incoming Message" event type
-    emailTrigger = await sdk.api.automation_triggers.createOne({
+    const emailTrigger = await sdk.api.automation_triggers.createOne({
       title: `Email Message Assignment Test ${Date.now()}`,
       status: 'Active',
       event: {
@@ -55,7 +89,7 @@ export const message_assignment_trigger_tests = async ({ sdk }: { sdk: Session }
       }
     })
 
-    smsTrigger = await sdk.api.automation_triggers.createOne({
+    const smsTrigger = await sdk.api.automation_triggers.createOne({
       title: `SMS Message Assignment Test ${Date.now()}`,
       status: 'Active',
       event: {
@@ -73,7 +107,7 @@ export const message_assignment_trigger_tests = async ({ sdk }: { sdk: Session }
       }
     })
 
-    chatTrigger = await sdk.api.automation_triggers.createOne({
+    const chatTrigger = await sdk.api.automation_triggers.createOne({
       title: `Chat Message Assignment Test ${Date.now()}`,
       status: 'Active',
       event: {
@@ -98,71 +132,61 @@ export const message_assignment_trigger_tests = async ({ sdk }: { sdk: Session }
 
     // Test 1: Email Message Assignment
     console.log(`\n=== Testing Email Message Assignment ===`)
-    
+
     // Create email with logOnly: true to prevent actual sending
     // Note: In real scenarios, emails have source fields added by the system
     // For testing purposes, we'll create the email and test the assignment logic
-    emailMessage = await sdk.api.emails.createOne({
+    const emailMessage = await sdk.api.emails.createOne({
       logOnly: true,
       enduserId: emailPatient.id,
       subject: 'Test Incoming Email __TELLESCOPE_TEST_INCOMING_EMAIL_AUTOMATION__',
       textContent: 'This is a test incoming email for assignment __TELLESCOPE_TEST_INCOMING_EMAIL_AUTOMATION__',
     })
     console.log(`Created email message: ${emailMessage.id}`)
-    console.log(`Note: In production, creating an inbound email would automatically trigger the Incoming Message event`)
-    console.log(`For testing, we rely on the trigger system to process the created email`)
 
     // Wait for trigger processing
     await wait(undefined, 1000)
 
-    // Check if email was assigned
-    const updatedEmail = await sdk.api.emails.getOne(emailMessage.id)
-    console.log(`Email assignment result:`)
-    console.log(`  assignedTo: ${JSON.stringify(updatedEmail.assignedTo)}`)
-    console.log(`  Expected user: ${sdk.userInfo.id}`)
-    
-    const emailAssigned = updatedEmail.assignedTo?.includes(sdk.userInfo.id) ?? false
-    if (emailAssigned) {
-      console.log(`✅ Email message successfully assigned to user`)
-    } else {
-      console.log(`❌ Email message assignment failed`)
-    }
-
-    // Test 2: SMS Message Assignment  
+    const updatedEmail = await poll_for_results(
+      () => sdk.api.emails.getOne(emailMessage.id),
+      e => !!e.assignedTo?.includes(sdk.userInfo.id),
+    )
+    record(
+      'Email message successfully assigned to user',
+      updatedEmail.assignedTo?.includes(sdk.userInfo.id) ?? false,
+      `assignedTo=${JSON.stringify(updatedEmail.assignedTo)} expected to include ${sdk.userInfo.id}`,
+    )
+
+    // Test 2: SMS Message Assignment
     console.log(`\n=== Testing SMS Message Assignment ===`)
-    
+
     // Create inbound SMS with logOnly: true and inbound: true
-    smsMessage = await sdk.api.sms_messages.createOne({
+    const smsMessage = await sdk.api.sms_messages.createOne({
       logOnly: true,
       inbound: true, // Critical: only inbound messages should trigger
       enduserId: smsPatient.id,
       message: 'This is a test incoming SMS for assignment __TELLESCOPE_TEST_INCOMING_SMS_AUTOMATION__',
     })
     console.log(`Created SMS message: ${smsMessage.id}`)
-    console.log(`Note: In production, creating an inbound SMS would automatically trigger the Incoming Message event`)
-    console.log(`For testing, we rely on the trigger system to process the created SMS`)
 
     // Wait for trigger processing
     await wait(undefined, 1000)
 
-    // Check if SMS was assigned
-    const updatedSMS = await sdk.api.sms_messages.getOne(smsMessage.id)
-    console.log(`SMS assignment result:`)
-    console.log(`  assignedTo: ${JSON.stringify(updatedSMS.assignedTo)}`)
-    console.log(`  Expected user: ${sdk.userInfo.id}`)
-    
-    const smsAssigned = updatedSMS.assignedTo?.includes(sdk.userInfo.id) ?? false
-    if (smsAssigned) {
-      console.log(`✅ SMS message successfully assigned to user`)
-    } else {
-      console.log(`❌ SMS message assignment failed`)
-    }
+    const updatedSMS = await poll_for_results(
+      () => sdk.api.sms_messages.getOne(smsMessage.id),
+      s => !!s.assignedTo?.includes(sdk.userInfo.id),
+    )
+    record(
+      'SMS message successfully assigned to user',
+      updatedSMS.assignedTo?.includes(sdk.userInfo.id) ?? false,
+      `assignedTo=${JSON.stringify(updatedSMS.assignedTo)} expected to include ${sdk.userInfo.id}`,
+    )
 
     // Test 3: Chat Room Assignment
     console.log(`\n=== Testing Chat Room Assignment ===`)
-    
+
     // Create a chat room for the patient
-    chatRoom = await sdk.api.chat_rooms.createOne({
+    const chatRoom = await sdk.api.chat_rooms.createOne({
       aboutEnduserId: chatPatient.id,
       userIds: [sdk.userInfo.id],
       enduserIds: [chatPatient.id],
@@ -170,124 +194,74 @@ export const message_assignment_trigger_tests = async ({ sdk }: { sdk: Session }
     console.log(`Created chat room: ${chatRoom.id}`)
 
     // Create a chat message in the room (this represents an incoming message)
-    chatMessage = await sdk.api.chats.createOne({
+    const chatMessage = await sdk.api.chats.createOne({
       roomId: chatRoom.id,
       message: 'This is a test incoming chat message for assignment',
       senderId: chatPatient.id, // Message from patient (incoming)
     })
     console.log(`Created chat message: ${chatMessage.id}`)
-    console.log(`Note: In production, creating an inbound chat would automatically trigger the Incoming Message event`)
-    console.log(`For testing, we rely on the trigger system to process the created chat message`)
 
     // Wait for trigger processing
     await wait(undefined, 1000)
 
-    // Check if chat room was assigned
-    const updatedChatRoom = await sdk.api.chat_rooms.getOne(chatRoom.id)
-    console.log(`Chat room assignment result:`)
-    console.log(`  assignedTo: ${JSON.stringify(updatedChatRoom.assignedTo)}`)
-    console.log(`  Expected user: ${sdk.userInfo.id}`)
-    
-    const chatAssigned = updatedChatRoom.assignedTo?.includes(sdk.userInfo.id) ?? false
-    if (chatAssigned) {
-      console.log(`✅ Chat room successfully assigned to user`)
-    } else {
-      console.log(`❌ Chat room assignment failed`)
-    }
+    const updatedChatRoom = await poll_for_results(
+      () => sdk.api.chat_rooms.getOne(chatRoom.id),
+      r => !!r.assignedTo?.includes(sdk.userInfo.id),
+    )
+    record(
+      'Chat room successfully assigned to user',
+      updatedChatRoom.assignedTo?.includes(sdk.userInfo.id) ?? false,
+      `assignedTo=${JSON.stringify(updatedChatRoom.assignedTo)} expected to include ${sdk.userInfo.id}`,
+    )
 
     // Test 4: Verify outbound messages don't trigger assignment
     console.log(`\n=== Testing Outbound Message Exclusion ===`)
-    
-    // Create outbound SMS (should NOT trigger assignment)
+
+    // Create outbound SMS (should NOT trigger assignment).
+    // Its own patient, not smsPatient: the SMS trigger already fired for smsPatient seconds ago and
+    // triggers are throttled to one fire per trigger per enduser per minute, so reusing them would
+    // make this check pass even if the product regressed and ran the trigger on outbound messages.
     const outboundSMS = await sdk.api.sms_messages.createOne({
       logOnly: true,
       inbound: false, // Outbound message
-      enduserId: smsPatient.id,
+      enduserId: outboundPatient.id,
       message: 'This is an outbound SMS that should not trigger assignment __TELLESCOPE_TEST_INCOMING_SMS_AUTOMATION__',
     })
     console.log(`Created outbound SMS: ${outboundSMS.id}`)
 
-    console.log(`Outbound SMS created for verification that it should NOT be assigned`)
-    console.log(`The Incoming Message trigger should only activate for inbound: true messages`)
-
     // Wait for potential trigger processing
     await wait(undefined, 1000)
 
     // Verify outbound SMS was NOT assigned (should still be null/undefined)
     const unchangedOutboundSMS = await sdk.api.sms_messages.getOne(outboundSMS.id)
-    const outboundNotAssigned = !unchangedOutboundSMS.assignedTo || unchangedOutboundSMS.assignedTo.length === 0
-    
-    if (outboundNotAssigned) {
-      console.log(`✅ Outbound SMS correctly NOT assigned (as expected)`)
-    } else {
-      console.log(`❌ Outbound SMS was incorrectly assigned: ${JSON.stringify(unchangedOutboundSMS.assignedTo)}`)
-    }
-
-    // Summary
-    console.log(`\n=== Test Results Summary ===`)
-    console.log(`Email Assignment: ${emailAssigned ? '✅ PASSED' : '❌ FAILED'}`)
-    console.log(`SMS Assignment: ${smsAssigned ? '✅ PASSED' : '❌ FAILED'}`)
-    console.log(`Chat Assignment: ${chatAssigned ? '✅ PASSED' : '❌ FAILED'}`)
-    console.log(`Outbound Exclusion: ${outboundNotAssigned ? '✅ PASSED' : '❌ FAILED'}`)
-
-    const allTestsPassed = emailAssigned && smsAssigned && chatAssigned && outboundNotAssigned
-    console.log(`\nOverall Result: ${allTestsPassed ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED'}`)
-
-    if (!allTestsPassed) {
-      throw new Error('Message assignment trigger tests failed')
-    }
-
-    // Cleanup test triggers
-    await Promise.all([
-      sdk.api.automation_triggers.deleteOne(emailTrigger.id),
-      sdk.api.automation_triggers.deleteOne(smsTrigger.id), 
-      sdk.api.automation_triggers.deleteOne(chatTrigger.id),
-    ])
-    console.log(`Cleaned up test triggers`)
-
-    // Cleanup test patients  
-    await Promise.all([
-      sdk.api.endusers.deleteOne(emailPatient.id),
-      sdk.api.endusers.deleteOne(smsPatient.id),
-      sdk.api.endusers.deleteOne(chatPatient.id),
-    ])
-    console.log(`Cleaned up test patients`)
-
-    return { success: true, results: { emailAssigned, smsAssigned, chatAssigned, outboundNotAssigned } }
-
+    record(
+      'Outbound SMS correctly NOT assigned (as expected)',
+      !unchangedOutboundSMS.assignedTo || unchangedOutboundSMS.assignedTo.length === 0,
+      `assignedTo=${JSON.stringify(unchangedOutboundSMS.assignedTo)} expected empty`,
+    )
   } finally {
-    // Ensure cleanup even if tests fail
-    try {
-      const cleanupPromises = []
-      
-      if (emailTrigger?.id) cleanupPromises.push(sdk.api.automation_triggers.deleteOne(emailTrigger.id).catch(() => {}))
-      if (smsTrigger?.id) cleanupPromises.push(sdk.api.automation_triggers.deleteOne(smsTrigger.id).catch(() => {}))
-      if (chatTrigger?.id) cleanupPromises.push(sdk.api.automation_triggers.deleteOne(chatTrigger.id).catch(() => {}))
-      
-      if (emailPatient?.id) cleanupPromises.push(sdk.api.endusers.deleteOne(emailPatient.id).catch(() => {}))
-      if (smsPatient?.id) cleanupPromises.push(sdk.api.endusers.deleteOne(smsPatient.id).catch(() => {}))
-      if (chatPatient?.id) cleanupPromises.push(sdk.api.endusers.deleteOne(chatPatient.id).catch(() => {}))
-      
-      await Promise.all(cleanupPromises)
-      console.log(`Final cleanup completed`)
-    } catch (error) {
-      console.error(`Cleanup error: ${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 and for sequential use in the suite. */
+export const message_assignment_trigger_tests = async () => {
+  assert_checks('Message assignment trigger', await message_assignment_trigger_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Message assignment trigger',
+  run: message_assignment_trigger_checks,
 }
 
 // Allow running this test file independently
 if (require.main === module) {
-  const host = process.env.API_URL || 'http://localhost:8080'
   console.log(`🌐 Using API URL: ${host}`)
-  const sdk = new Session({ host })
-
-  const runTests = async () => {
-    await setup_tests(sdk, sdk) // Use same SDK for both admin and non-admin (simplified for this test)
-    await message_assignment_trigger_tests({ sdk })
-  }
-  
-  runTests()
+  message_assignment_trigger_tests()
     .then(() => {
       console.log("✅ Message assignment trigger tests completed successfully")
       process.exit(0)
@@ -296,4 +270,4 @@ if (require.main === module) {
       console.error("❌ Message assignment trigger tests failed:", error)
       process.exit(1)
     })
-}
+}