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

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

@@ -1,27 +1,76 @@
-import { Session } from '../../sdk'
-import { log_header, wait } from "@tellescope/testing"
+require('source-map-support').install();
+
+import { wait } from "@tellescope/testing"
 import { AUTOMATED_ACTION_CANCEL_REASONS } from "@tellescope/constants"
+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)
+
+/**
+ * Deleting a journey must cascade-cancel its pending automated_actions (with the Journey Deleted
+ * reason, attributed to the deleting user) and leave finished ones untouched.
+ *
+ * Provisions its own throwaway tenant: the journey, its step and its automated_actions are org-wide
+ * records, and the cascade runs over every action of the journey.
+ */
+
+/**
+ * Polls until `evaluateFn` passes, returning the LAST value seen — a timeout returns rather than
+ * throwing, so the caller records a FAIL Check with the evidence. A rejection here would abort the
+ * whole parallel batch instead of letting the other suites report.
+ */
+const pollForResults = async <T>(
+  fetchFn: () => Promise<T>,
+  evaluateFn: (result: T) => boolean,
+  description: string,
+  intervalMs = 500,
+  maxIterations = 30,
+): Promise<{ result: T, timedOut: boolean }> => {
+  let lastResult = await fetchFn()
 
-const host = process.env.API_URL || 'http://localhost:8080'
+  for (let i = 0; i < maxIterations; i++) {
+    if (evaluateFn(lastResult)) {
+      console.log(`✓ ${description} - completed after ${i * intervalMs}ms`)
+      return { result: lastResult, timedOut: false }
+    }
 
-export const journey_delete_cancels_actions_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Journey Delete Cancels Pending Actions Tests")
+    await wait(undefined, intervalMs)
+    lastResult = await fetchFn()
+  }
+
+  console.log('Final polling result:', lastResult)
+  return { result: lastResult, timedOut: !evaluateFn(lastResult) }
+}
+
+export const journey_delete_cancels_actions_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  let journeyId: string | undefined
-  let enduserId: string | undefined
-  let stepId: string | undefined
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Journey delete cancels actions ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     // Create a journey + an automation_step
     const journey = await sdk.api.journeys.createOne({ title: "Cascade Cancel Journey " + Date.now() })
-    journeyId = journey.id
 
     const step = await sdk.api.automation_steps.createOne({
       journeyId: journey.id,
       action: { type: 'setEnduserStatus', info: { status: 'Test Status' } },
       events: [{ type: 'onJourneyStart', info: {} }],
     })
-    stepId = step.id
 
     // Create an enduser
     const enduser = await sdk.api.endusers.createOne({
@@ -29,7 +78,6 @@ export const journey_delete_cancels_actions_tests = async ({ sdk, sdkNonAdmin }:
       lname: 'Cancel',
       email: 'test-cascade-cancel-' + Date.now() + '@example.com',
     })
-    enduserId = enduser.id
 
     // Create an active action with a far-future processAfter so the worker won't process it during the test
     const activeAction = await sdk.api.automated_actions.createOne({
@@ -53,26 +101,24 @@ export const journey_delete_cancels_actions_tests = async ({ sdk, sdkNonAdmin }:
       action: { type: 'setEnduserStatus', info: { status: 'Test Status' } },
     })
 
-    // Assert the action starts active
+    // Check the action starts active
     const before = await sdk.api.automated_actions.getOne(activeAction.id)
-    if (before.status !== 'active') {
-      throw new Error(`Expected action to start 'active', got '${before.status}'`)
-    }
-    console.log("✓ Action is active before journey deletion")
+    record(
+      'Action is active before journey deletion',
+      before.status === 'active',
+      `status=${before.status}`,
+    )
 
     // Delete the journey — this should cascade cancel the pending action
     await sdk.api.journeys.deleteOne(journey.id)
-    journeyId = undefined // already deleted, skip in cleanup
 
     // Poll until the active action transitions to cancelled with the Journey Deleted reason,
     // attributed to the deleting user via cancelledBy
     const expectedReason = AUTOMATED_ACTION_CANCEL_REASONS.indexOf('Journey Deleted')
-    await pollForResults(
+    const { result: polled, timedOut } = await pollForResults(
       async () => {
         const actions = await sdk.api.automated_actions.getSome({ filter: { enduserId: enduser.id } })
-        const active = actions.find(a => a.id === activeAction.id)
-        const finished = actions.find(a => a.id === finishedAction.id)
-        return { active, finished }
+        return { active: actions.find(a => a.id === activeAction.id) }
       },
       ({ active }) => (
         active?.status === 'cancelled'
@@ -81,7 +127,14 @@ export const journey_delete_cancels_actions_tests = async ({ sdk, sdkNonAdmin }:
       ),
       'Active action should be cancelled with Journey Deleted reason and cancelledBy after journey deletion',
     )
-    console.log("✓ Active action cancelled with Journey Deleted reason and cancelledBy set to deleting user")
+    record(
+      'Active action cancelled with Journey Deleted reason and cancelledBy set to deleting user',
+      !timedOut,
+      timedOut
+        ? `polling timed out after ~14.5s — action=${JSON.stringify(polled.active)},`
+          + ` expected status=cancelled, cancelReason=${expectedReason}, cancelledBy=${sdk.userInfo.id}`
+        : `action=${JSON.stringify(polled.active)}`,
+    )
 
     // Not covered here: journey deletion also removes outstanding_froms_trackers. Creating a tracker
     // requires an automation to actually send an email/SMS with multiple form links, and the collection
@@ -89,58 +142,34 @@ export const journey_delete_cancels_actions_tests = async ({ sdk, sdkNonAdmin }:
 
     // Confirm the finished action was left untouched
     const finishedAfter = await sdk.api.automated_actions.getOne(finishedAction.id)
-    if (finishedAfter.status !== 'finished') {
-      throw new Error(`Expected finished action to remain 'finished', got '${finishedAfter.status}'`)
-    }
-    console.log("✓ Finished action left untouched")
-
-    console.log("✅ Journey Delete Cancels Pending Actions tests completed successfully")
+    record(
+      'Finished action left untouched',
+      finishedAfter.status === 'finished',
+      `status=${finishedAfter.status}`,
+    )
   } finally {
-    // Cleanup — journey is already deleted if the flow completed
-    await Promise.all([
-      enduserId ? sdk.api.endusers.deleteOne(enduserId).catch(() => {}) : undefined,
-      stepId ? sdk.api.automation_steps.deleteOne(stepId).catch(() => {}) : undefined,
-      journeyId ? sdk.api.journeys.deleteOne(journeyId).catch(() => {}) : undefined,
-    ])
+    // 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) } }
   }
-}
 
-const pollForResults = async <T>(
-  fetchFn: () => Promise<T>,
-  evaluateFn: (result: T) => boolean,
-  description: string,
-  intervalMs = 500,
-  maxIterations = 30,
-): Promise<void> => {
-  let lastResult: T | undefined
-
-  for (let i = 0; i < maxIterations; i++) {
-    await wait(undefined, intervalMs)
+  return checks
+}
 
-    lastResult = await fetchFn()
-    if (evaluateFn(lastResult)) {
-      console.log(`✓ ${description} - completed after ${(i + 1) * intervalMs}ms`)
-      return
-    }
-  }
+/** Asserting wrapper, for standalone runs. */
+export const journey_delete_cancels_actions_tests = async () => {
+  assert_checks('Journey delete cancels actions', await journey_delete_cancels_actions_checks())
+}
 
-  console.log('Final polling result:', lastResult)
-  throw new Error(`Polling timeout: ${description} - waited ${maxIterations * intervalMs}ms`)
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Journey delete cancels actions',
+  run: journey_delete_cancels_actions_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 () => {
-    const { setup_tests } = await import("../setup")
-    await setup_tests(sdk, sdkNonAdmin)
-    await journey_delete_cancels_actions_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  journey_delete_cancels_actions_tests()
     .then(() => {
       console.log("✅ Journey Delete Cancels Pending Actions test suite completed successfully")
       process.exit(0)

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

@@ -25,12 +25,19 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     lname: 'TestPatient',
   })
 
+  // load_team_chat orders and keyset-pages on recentMessageSentAt, and a room that has never had a
+  // message (no recentMessageSentAt) is not returned at all — so every fixture room below sets one.
+  // Distinct, descending values make the ordering and pagination assertions deterministic.
+  const SENT_AT_BASE = Date.now()
+  const sent_at = (secondsAgo: number) => SENT_AT_BASE - secondsAgo * 1000
+
   // Create various team chat rooms for testing
   // Room 1: Non-admin is in userIds
   const roomWithUserInIds = await sdk.api.chat_rooms.createOne({
     type: 'internal',
     userIds: [sdkNonAdmin.userInfo.id],
     title: 'Room with user in userIds',
+    recentMessageSentAt: sent_at(1),
   })
 
   // Room 2: Non-admin is creator
@@ -38,6 +45,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [],
     title: 'Room where user is creator',
+    recentMessageSentAt: sent_at(2),
   })
 
   // Room 3: aboutEnduserId with care team access
@@ -46,6 +54,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [],
     aboutEnduserId: enduserForCareTeam.id,
     title: 'Room with care team access',
+    recentMessageSentAt: sent_at(3),
   })
 
   // Room 4: No access for non-admin (different creator, not in userIds, no care team)
@@ -53,6 +62,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [],
     title: 'Room with no access for non-admin',
+    recentMessageSentAt: sent_at(4),
   })
 
   // Room 4b: No access for admin (non-admin is creator, admin not in userIds, not on care team)
@@ -60,6 +70,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [],
     title: 'Room with no access for admin',
+    recentMessageSentAt: sent_at(5),
   })
 
   // Room 5: aboutEnduserId but non-admin NOT on care team
@@ -68,6 +79,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [],
     aboutEnduserId: enduserNotOnCareTeam.id,
     title: 'Room without care team access',
+    recentMessageSentAt: sent_at(6),
   })
 
   // Room 6: Closed room (has endedAt)
@@ -75,6 +87,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [sdkNonAdmin.userInfo.id],
     title: 'Closed room',
+    recentMessageSentAt: sent_at(7),
     endedAt: new Date(),
   })
 
@@ -83,6 +96,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'external',
     userIds: [sdkNonAdmin.userInfo.id],
     title: 'External room',
+    recentMessageSentAt: sent_at(8),
   })
 
   // Room 8: Room with enduserIds (should be excluded - not a team chat)
@@ -91,6 +105,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [sdkNonAdmin.userInfo.id],
     enduserIds: [enduserForCareTeam.id],
     title: 'Room with endusers',
+    recentMessageSentAt: sent_at(9),
   })
 
   // Room 9: Room with empty string aboutEnduserId (should not crash, user in userIds can see it)
@@ -99,6 +114,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [sdkNonAdmin.userInfo.id],
     aboutEnduserId: '' as any, // Empty string should be handled gracefully
     title: 'Room with empty aboutEnduserId',
+    recentMessageSentAt: sent_at(10),
   })
 
   // Wait for timestamps to settle
@@ -228,7 +244,8 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     const lastRoom = firstBatch.chat_rooms[firstBatch.chat_rooms.length - 1]
     await async_test(
       "Pagination with lastUpdatedAt returns older rooms",
-      () => sdk.api.chat_rooms.load_team_chat({ lastUpdatedAt: new Date(lastRoom.updatedAt!) }),
+      // the cursor parameter keeps its name and Date type, but now carries recentMessageSentAt
+      () => sdk.api.chat_rooms.load_team_chat({ lastUpdatedAt: new Date(lastRoom.recentMessageSentAt!) }),
       {
         onResult: r => {
           // Should not contain any rooms from first batch
@@ -239,22 +256,59 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     )
   }
 
-  // Test 14: Sorted by updatedAt descending
+  // Test 14: Sorted by recentMessageSentAt descending
   await async_test(
-    "Results sorted by updatedAt descending",
+    "Results sorted by recentMessageSentAt descending",
     () => sdk.api.chat_rooms.load_team_chat({}),
     {
       onResult: r => {
+        if (r.chat_rooms.length === 0) return false
+        for (const room of r.chat_rooms) {
+          if (room.recentMessageSentAt === undefined) return false // never-messaged rooms are excluded
+        }
         for (let i = 1; i < r.chat_rooms.length; i++) {
-          const prev = new Date(r.chat_rooms[i - 1].updatedAt!).getTime()
-          const curr = new Date(r.chat_rooms[i].updatedAt!).getTime()
-          if (prev < curr) return false
+          if (r.chat_rooms[i - 1].recentMessageSentAt! < r.chat_rooms[i].recentMessageSentAt!) return false
         }
         return true
       }
     }
   )
 
+  // Test 14b: a write that is not a message must not re-order a room. updatedAt is bumped by any
+  // write (it was the old sort key); recentMessageSentAt is not.
+  const FIXTURE_ROOM_IDS = [
+    roomWithUserInIds.id, roomWithCareTeamAccess.id, roomNoAccessForNonAdmin.id,
+    roomNoCareTeamAccess.id, roomWithEmptyAboutEnduserId.id,
+  ]
+  const fixture_order = (rooms: { id: string }[]) => (
+    rooms.map(room => room.id).filter(id => FIXTURE_ROOM_IDS.includes(id)).join(',')
+  )
+
+  const orderBeforeRename = fixture_order((await sdk.api.chat_rooms.load_team_chat({})).chat_rooms)
+  const renamedTitle = 'Room with empty aboutEnduserId (renamed)'
+  // the oldest fixture room by recentMessageSentAt: before this change, the rename put it first
+  await sdk.api.chat_rooms.updateOne(roomWithEmptyAboutEnduserId.id, { title: renamedTitle })
+  await wait(undefined, 500)
+
+  await async_test(
+    "A non-message update does not re-order a room",
+    () => sdk.api.chat_rooms.load_team_chat({}),
+    {
+      onResult: r => {
+        const renamed = r.chat_rooms.find(room => room.id === roomWithEmptyAboutEnduserId.id)
+        const orderAfterRename = fixture_order(r.chat_rooms)
+        return (
+          renamed?.title === renamedTitle // the write did land
+          && renamed?.recentMessageSentAt === sent_at(10) // and left the sort key alone
+          && orderAfterRename === orderBeforeRename
+          // still last of the fixture rooms, not first
+          && r.chat_rooms.map(room => room.id).indexOf(roomWithEmptyAboutEnduserId.id)
+             > r.chat_rooms.map(room => room.id).indexOf(roomWithUserInIds.id)
+        )
+      }
+    }
+  )
+
   // ============================================
   // Enduser Access Control Tests
   // ============================================
@@ -297,6 +351,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [enduserAccessTestUser.id],
     aboutEnduserId: enduserNotAssignedToTestUser.id,
     title: 'Room with unassigned enduser',
+    recentMessageSentAt: sent_at(11),
   })
 
   await wait(undefined, 500)
@@ -425,6 +480,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [accessTagTestUser.id],
     aboutEnduserId: enduserWithAccessTag.id,
     title: 'Room with access tag enduser',
+    recentMessageSentAt: sent_at(12),
   })
 
   await wait(undefined, 2000) // role change triggers logout