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

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

@@ -1,23 +1,64 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import { CreateNoteAutomationAction } from "@tellescope/types-models"
-import { log_header, async_test, assert } from "@tellescope/testing"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
 
-const host = process.env.API_URL || "http://localhost:8080"
+const host = process.env.API_URL || 'http://localhost:8080' as const
 
-// createNote journey action: creates a note on the enduser timeline with deterministic
-// (merge-field) text, or AI-generated text when aiSummaryConfiguration.enabled is set.
-// The deterministic path is fully covered here; the AI path asserts config round-trip and,
-// when the org lacks Bedrock enablement/credits (typical dev org), the error path instead.
-export const create_note_action_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Create Note Action Tests")
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
-  const journey = await sdk.api.journeys.createOne({ title: 'Create Note Test Journey' })
-  const createdEnduserIds: string[] = []
+const error_text = (err: unknown) => {
+  const message = (err as any)?.message ?? err
+  return typeof message === 'string' ? message : JSON.stringify(message)
+}
+
+/** Renders a value for a check's detail string. Never `JSON.stringify(x) || fallback`:
+ *  JSON.stringify('') is '""', which is truthy, so the fallback would be unreachable. */
+const show = (v: unknown) => v === undefined ? '(unset)' : JSON.stringify(v)
+
+/**
+ * createNote journey action: creates a note on the enduser timeline with deterministic
+ * (merge-field) text, or AI-generated text when aiSummaryConfiguration.enabled is set.
+ * The deterministic path is fully covered here; the AI path asserts config round-trip and the
+ * error path a tenant without Bedrock enablement/credits takes.
+ *
+ * Provisions its own throwaway tenant: the journey, its steps and the automated_actions processed
+ * below are org-wide, and the note assertions count every note on the patient.
+ *
+ * Not covered here: the AI happy path (an AI-generated note, its aiGenerated flag and its
+ * ai_conversations record). A provisioned tenant has no Bedrock enablement, so that arm cannot run.
+ */
+export const create_note_action_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  // async_test's shouldError path calls process.exit on failure, which would strand the tenant.
+  const expect_rejected = async (label: string, write: () => Promise<any>) => {
+    try {
+      await write()
+      record(label, false, 'the write was accepted, but it should have been rejected')
+    } catch (err) {
+      record(label, true, `rejected with: ${error_text(err) || '(no message on the rejection)'}`)
+    }
+  }
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `createNote action ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    const journey = await sdk.api.journeys.createOne({ title: 'Create Note Test Journey' })
+
     /*************** Config validation round-trip ***************/
     const validInfo = {
       title: 'Note for {{enduser.fname}}',
@@ -30,27 +71,25 @@ export const create_note_action_tests = async ({ sdk } : { sdk: Session, sdkNonA
       events: [{ type: 'onJourneyStart', info: {} }],
       action: { type: 'createNote', info: validInfo },
     })
-    assert(
-      step.action.type === 'createNote' && step.action.info.title === validInfo.title && step.action.info.text === validInfo.text,
-      'createNote step round-trip failed',
+    record(
       'createNote step round-trips',
+      step.action.type === 'createNote' && step.action.info.title === validInfo.title && step.action.info.text === validInfo.text,
+      `action=${JSON.stringify(step.action)}`,
     )
 
-    await async_test('createNote without title is rejected',
+    await expect_rejected('createNote without title is rejected',
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
         events: [{ type: 'onJourneyStart', info: {} }],
         action: { type: 'createNote', info: { ...validInfo, title: undefined } as any },
       }),
-      { shouldError: true, onError: () => true },
     )
-    await async_test('createNote with over-length title is rejected',
+    await expect_rejected('createNote with over-length title is rejected',
       () => sdk.api.automation_steps.createOne({
         journeyId: journey.id,
         events: [{ type: 'onJourneyStart', info: {} }],
         action: { type: 'createNote', info: { ...validInfo, title: 'x'.repeat(251) } },
       }),
-      { shouldError: true, onError: () => true },
     )
 
     /*************** Runtime: the process endpoint ***************/
@@ -69,29 +108,60 @@ export const create_note_action_tests = async ({ sdk } : { sdk: Session, sdkNonA
 
     // deterministic path: merge fields resolve, tags + source set
     const enduser = await sdk.api.endusers.createOne({ fname: 'NoteTest' })
-    createdEnduserIds.push(enduser.id)
 
     const result = await processFor(enduser.id, validInfo)
-    assert(result.success === true, `deterministic createNote failed: ${result.error}`, 'deterministic createNote succeeds')
+    record(
+      'deterministic createNote succeeds',
+      result.success === true,
+      `success=${show(result.success)}, error=${show(result.error)}`,
+    )
 
     const notes = await sdk.api.notes.getSome({ filter: { enduserId: enduser.id } })
-    assert(notes.length === 1, `expected 1 note, got ${notes.length}`, 'exactly one note created')
-    assert(notes[0].title === 'Note for NoteTest', `title not templated: ${notes[0].title}`, 'title merge fields resolve')
-    assert(notes[0].text === 'Hi NoteTest, this is a journey note.', `text not templated: ${notes[0].text}`, 'text merge fields resolve')
-    assert(!!notes[0].tags?.includes('auto-note'), 'tags missing on note', 'tags set on note')
-    assert(notes[0].source === 'Journey', `wrong source: ${notes[0].source}`, 'note source is Journey')
-    assert(!notes[0].hiddenFromTimeline, 'note unexpectedly hidden', 'note visible on timeline by default')
-    assert(!notes[0].aiGenerated, 'deterministic note incorrectly flagged aiGenerated', 'deterministic note not flagged as AI-generated')
+    record('exactly one note created', notes.length === 1, `expected 1 note, got ${notes.length}`)
+    record(
+      'title merge fields resolve',
+      notes[0]?.title === 'Note for NoteTest',
+      `title=${show(notes[0]?.title)}`,
+    )
+    record(
+      'text merge fields resolve',
+      notes[0]?.text === 'Hi NoteTest, this is a journey note.',
+      `text=${show(notes[0]?.text)}`,
+    )
+    record(
+      'tags set on note',
+      !!notes[0]?.tags?.includes('auto-note'),
+      `tags=${show(notes[0]?.tags)}`,
+    )
+    record(
+      'note source is Journey',
+      notes[0]?.source === 'Journey',
+      `source=${show(notes[0]?.source)}`,
+    )
+    record(
+      'note visible on timeline by default',
+      !notes[0]?.hiddenFromTimeline,
+      `hiddenFromTimeline=${show(notes[0]?.hiddenFromTimeline)}`,
+    )
+    record(
+      'deterministic note not flagged as AI-generated',
+      !notes[0]?.aiGenerated,
+      `aiGenerated=${show(notes[0]?.aiGenerated)}`,
+    )
 
     // hiddenFromTimeline + no text variant
     const hiddenResult = await processFor(enduser.id, { title: 'Hidden note', hiddenFromTimeline: true })
-    assert(hiddenResult.success === true, `hidden createNote failed: ${hiddenResult.error}`, 'hidden createNote succeeds')
+    record(
+      'hidden createNote succeeds',
+      hiddenResult.success === true,
+      `success=${show(hiddenResult.success)}, error=${show(hiddenResult.error)}`,
+    )
     const allNotes = await sdk.api.notes.getSome({ filter: { enduserId: enduser.id } })
     const hiddenNote = allNotes.find(n => n.title === 'Hidden note')
-    assert(
-      !!hiddenNote && hiddenNote.hiddenFromTimeline === true && !hiddenNote.text,
-      'hidden/textless note not created correctly',
+    record(
       'hiddenFromTimeline note created without text',
+      !!hiddenNote && hiddenNote.hiddenFromTimeline === true && !hiddenNote.text,
+      `note=${hiddenNote ? JSON.stringify(hiddenNote) : '(no note titled "Hidden note")'}`,
     )
 
     /*************** AI path ***************/
@@ -107,56 +177,65 @@ export const create_note_action_tests = async ({ sdk } : { sdk: Session, sdkNonA
       events: [{ type: 'onJourneyStart', info: {} }],
       action: { type: 'createNote', info: aiInfo },
     })
-    assert(
-      aiStep.action.type === 'createNote' && aiStep.action.info.aiSummaryConfiguration?.enabled === true,
-      'AI createNote config round-trip failed',
+    record(
       'AI createNote config round-trips',
+      aiStep.action.type === 'createNote' && aiStep.action.info.aiSummaryConfiguration?.enabled === true,
+      `action=${JSON.stringify(aiStep.action)}`,
     )
 
+    // bedrockAIAllowed/credits are org-level and a provisioned tenant has neither, so only the
+    // configuration-error path is covered: the AI happy path cannot run on a tenant without Bedrock.
+    // Observed locally, the call RESOLVES with { success: false, error: 'Organization has not set up
+    // credits' }; a rejection is accepted too, since which of the two a missing-Bedrock tenant
+    // produces depends on where generation gives up. Either way the message must name the reason —
+    // a bare failure would let an unrelated regression pass as "Bedrock unavailable".
     const aiEnduser = await sdk.api.endusers.createOne({ fname: 'AINoteTest' })
-    createdEnduserIds.push(aiEnduser.id)
-    const aiResult = await processFor(aiEnduser.id, aiInfo)
-    if (!aiResult.success) {
-      // bedrockAIAllowed/credits are org-level and unreadable here — accept the configuration error path
-      assert(
-        /bedrock|credit|enabled|ai/i.test(aiResult.error || ''),
-        `unexpected AI createNote error: ${aiResult.error}`,
-        'AI createNote reports a configuration error (Bedrock unavailable — runtime generation skipped)',
-      )
-    } else {
-      const aiNotes = await sdk.api.notes.getSome({ filter: { enduserId: aiEnduser.id } })
-      assert(
-        aiNotes.length === 1 && !!aiNotes[0].text && aiNotes[0].title === 'AI note for AINoteTest',
-        'AI-generated note missing or malformed',
-        'AI-generated note created with non-empty text',
-      )
-      assert(aiNotes[0].aiGenerated === true, 'AI note missing aiGenerated flag', 'AI note flagged as AI-generated')
-      const conversations = await sdk.api.ai_conversations.getSome({ filter: { enduserId: aiEnduser.id } })
-      assert(
-        conversations.some(c => c.type === 'AI Note'),
-        'no AI Note ai_conversations record',
-        'AI generation logged to ai_conversations with type AI Note',
+    const AI_LABEL = 'AI createNote reports a configuration error (Bedrock unavailable — runtime generation skipped)'
+    const CONFIGURATION_ERROR = /bedrock|credit|enabled|ai/i
+    try {
+      const aiResult = await processFor(aiEnduser.id, aiInfo)
+      if (aiResult?.success) {
+        record(
+          AI_LABEL,
+          false,
+          'expected the AI arm to fail on a tenant without Bedrock, but it reported success —'
+          + ' the AI happy path is deliberately not covered here',
+        )
+      } else {
+        record(
+          AI_LABEL,
+          CONFIGURATION_ERROR.test(aiResult?.error || ''),
+          `failed with: ${aiResult?.error || '(no error on the failed result)'}`,
+        )
+      }
+    } catch (err) {
+      const message = error_text(err)
+      record(
+        AI_LABEL,
+        CONFIGURATION_ERROR.test(message || ''),
+        `rejected with: ${message || '(no message on the rejection)'}`,
       )
     }
   } finally {
-    await sdk.api.journeys.deleteOne(journey.id).catch(() => {})
-    for (const id of createdEnduserIds) {
-      await sdk.api.endusers.deleteOne(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 create_note_action_tests = async () => {
+  assert_checks('createNote action', await create_note_action_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await create_note_action_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'createNote action', run: create_note_action_checks }
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  create_note_action_tests()
     .then(() => {
       console.log("✅ Create Note Action test suite completed successfully")
       process.exit(0)

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

@@ -1,168 +1,140 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import { 
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-// Test function that can be called independently
-export const create_user_notifications_trigger_tests = async ({ sdk } : { sdk: Session }) => {
-  log_header("Create User Notifications Trigger Tests")
-  
-  // Test resource tracking
-  let testEnduser: any
-  let triggerId: string | undefined
-  let formId: string | undefined
-  
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Covers the "Create User Notifications" automation action fired by a Field Equals trigger, and the
+ * relatedRecords it attaches to the notification it creates.
+ *
+ * Provisions its own throwaway tenant: the trigger is org-wide automation state, and the check reads
+ * user_notifications, which is business-wide — on the shared fixture it both fires against every
+ * other suite's patients and reads their notifications.
+ *
+ * The tenant admin is used twice over: as the enduser's care-team member (the action's
+ * `careTeamOnly` matches `enduser.assignedTo`) and as the notification's recipient.
+ */
+export const create_user_notifications_trigger_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
+
   try {
-    // Test 1: Setup - Create enduser assigned to the authenticated user
-    await async_test(
+    tenant = await setup_isolated_tenant({
+      name: `Create User Notifications trigger ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    // Setup - Create enduser assigned to the authenticated user
+    const testEnduser = await sdk.api.endusers.createOne({
+      assignedTo: [sdk.userInfo.id]
+    })
+    record(
       'setup - create test enduser assigned to authenticated user',
-      async () => {
-        testEnduser = await sdk.api.endusers.createOne({
-          assignedTo: [sdk.userInfo.id]
-        })
-        
-        return testEnduser.assignedTo?.length === 1 && testEnduser.assignedTo[0] === sdk.userInfo.id
-      },
-      { onResult: (result) => result === true }
+      testEnduser.assignedTo?.length === 1 && testEnduser.assignedTo[0] === sdk.userInfo.id,
+      `assignedTo=${JSON.stringify(testEnduser.assignedTo)}, expected [${sdk.userInfo.id}]`,
     )
 
     // set up trigger
-    await async_test(
-      'create trigger - field equals event',
-      async () => {
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `User Notification Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: { 
-              field: '0',
-              value: 'trigger-test'
-            }
-          },
-          action: {
-            type: 'Create User Notifications',
-            info: {
-              message: 'Field equals notification',
-              notificationType: 'field-equals-notification',
-              careTeamOnly: true,
-              maxUsers: 1
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
-      },
-      { onResult: (result) => result === true }
-    )
-
-    // Test 4: Submit form and verify notification
-    await async_test(
-      'submit form - verify notification created',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            '0': 'trigger-test'
-          }
-        })
-
-        // Wait up to 10 seconds for notification
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-          
-          const notifications = await sdk.api.user_notifications.getSome({ filter: {
-            type: 'field-equals-notification',
-            userId: sdk.userInfo.id
-          } })
-          
-          if (notifications.length > 0) {
-            console.log(`✓ Found notification after ${i + 1} seconds`)
-            
-            const notification = notifications[0]
-            
-            // Verify notification structure and relatedRecords
-            console.log(`Notification details:`)
-            console.log(`  - Type: ${notification.type}`)
-            console.log(`  - User ID: ${notification.userId}`)
-            console.log(`  - Message: ${notification.message}`)
-            console.log(`  - Related Records: ${JSON.stringify(notification.relatedRecords)}`)
-            
-            // Check if relatedRecords contains our test enduser
-            const hasCorrectEnduser = notification.relatedRecords?.some(record => 
-              record.type === 'enduser' && record.id === testEnduser.id
-            )
-            
-            if (!hasCorrectEnduser) {
-              console.log(`❌ Notification does not contain correct enduser ID`)
-              console.log(`   Expected enduser ID: ${testEnduser.id}`)
-              console.log(`   Found related records: ${JSON.stringify(notification.relatedRecords)}`)
-              return false
-            }
-            
-            console.log(`✓ Notification correctly associated with enduser ${testEnduser.id}`)
-            return true
-          }
+    const trigger = await sdk.api.automation_triggers.createOne({
+      title: `User Notification Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: '0',
+          value: 'trigger-test'
         }
-        
-        console.log(`❌ No notification found after 10 seconds`)
-        return false
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Create User Notifications',
+        info: {
+          message: 'Field equals notification',
+          notificationType: 'field-equals-notification',
+          careTeamOnly: true,
+          maxUsers: 1
+        }
+      }
+    })
+    record(
+      'create trigger - field equals event',
+      !!trigger.id,
+      `trigger id=${trigger.id || '(none returned)'}`,
     )
 
-    console.log("✅ Create User Notifications trigger test passed!")
-    
-  } catch (error) {
-    console.error('Test execution error:', error)
-    throw error
-  } finally {
-    // Cleanup
-    console.log("🧹 Cleaning up test resources...")
-    
-    try {
-      if (triggerId) {
-        await sdk.api.automation_triggers.deleteOne(triggerId)
-      }
-      
-      if (formId) {
-        await sdk.api.forms.deleteOne(formId)
+    // Set the field and verify the notification is created, with the enduser in relatedRecords
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        '0': 'trigger-test'
       }
-      
-      if (testEnduser?.id) {
-        await sdk.api.endusers.deleteOne(testEnduser.id)
-      }
-      
-      const testNotifications = (await sdk.api.user_notifications.getSome({}))
-        .filter(n => n.type === 'field-equals-notification')
-      
-      for (const notification of testNotifications) {
-        await sdk.api.user_notifications.deleteOne(notification.id)
-      }
-      
-    } catch (cleanupError) {
-      console.error('Cleanup error (non-fatal):', cleanupError)
+    })
+
+    // Wait up to 10 seconds for notification
+    let notification: Awaited<ReturnType<typeof sdk.api.user_notifications.getSome>>[number] | undefined
+    for (let i = 0; i < 10 && !notification; i++) {
+      await new Promise(resolve => setTimeout(resolve, 1000))
+
+      const notifications = await sdk.api.user_notifications.getSome({ filter: {
+        type: 'field-equals-notification',
+        userId: sdk.userInfo.id
+      } })
+
+      notification = notifications[0]
+    }
+
+    if (!notification) {
+      record(
+        'submit form - verify notification created',
+        false,
+        'no field-equals-notification for the care-team user after 10 seconds',
+      )
+    } else {
+      // Verify notification structure and relatedRecords
+      const hasCorrectEnduser = !!notification.relatedRecords?.some(r =>
+        r.type === 'enduser' && r.id === testEnduser.id
+      )
+      record(
+        'submit form - verify notification created',
+        hasCorrectEnduser,
+        `type=${notification.type}, userId=${notification.userId}, message=${notification.message},`
+        + ` relatedRecords=${JSON.stringify(notification.relatedRecords)}`
+        + (hasCorrectEnduser ? '' : ` — expected a related enduser record with id ${testEnduser.id}`),
+      )
     }
+  } finally {
+    // 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 create_user_notifications_trigger_tests = async () => {
+  assert_checks('Create User Notifications trigger', await create_user_notifications_trigger_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Create User Notifications trigger',
+  run: create_user_notifications_trigger_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 create_user_notifications_trigger_tests({ sdk })
-  }
-  
-  runTests()
+  create_user_notifications_trigger_tests()
     .then(() => {
       console.log("✅ Create User Notifications trigger test suite completed successfully")
       process.exit(0)
@@ -171,4 +143,4 @@ if (require.main === module) {
       console.error("❌ Create User Notifications trigger test suite failed:", error)
       process.exit(1)
     })
-}
+}