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

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

@@ -1,126 +1,160 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
+import { wait } from "@tellescope/testing"
 import {
-  async_test,
-  log_header,
-  wait,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
 const totalFromValues = (r: { values?: { value: number }[] }) =>
   (r.values ?? []).reduce((sum, v) => sum + v.value, 0)
 
-export const chats_analytics_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Chats Analytics Tests")
-
-  const testEnduser = await sdk.api.endusers.createOne({
-    fname: 'ChatsAnalytics',
-    lname: 'TestUser',
-    email: 'chats-analytics-test@example.com',
-  })
-
-  const chatRoom = await sdk.api.chat_rooms.createOne({
-    enduserIds: [testEnduser.id],
-  })
-
-  // Inbound chat (senderId === enduserId), tagged with 'tag-a'
-  const inboundChat = await sdk.api.chats.createOne({
-    roomId: chatRoom.id,
-    message: "Inbound message from enduser",
-    senderId: testEnduser.id,
-    enduserId: testEnduser.id,
-    tags: ['tag-a'],
-  })
-
-  // Outbound chat (senderId !== enduserId), tagged with 'tag-b'
-  const outboundChat = await sdk.api.chats.createOne({
-    roomId: chatRoom.id,
-    message: "Outbound message from provider",
-    senderId: sdk.userInfo.id,
-    enduserId: testEnduser.id,
-    tags: ['tag-b'],
-  })
-
-  // Inbound chat with both tags
-  const bothTagsChat = await sdk.api.chats.createOne({
-    roomId: chatRoom.id,
-    message: "Inbound message with both tags",
-    senderId: testEnduser.id,
-    enduserId: testEnduser.id,
-    tags: ['tag-a', 'tag-b'],
-  })
-
-  await wait(undefined, 1000)
-
-  const now = new Date()
-  const dayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate())
-  const dayEnd = new Date(dayStart.getTime() + 24 * 60 * 60 * 1000)
-
-  const baseQuery = {
-    resource: 'Chats' as const,
-    info: { method: 'Total' as const, parameters: undefined },
-    range: { interval: 'Daily' as const, key: 'Created At' as const },
-  }
-  const createdRange = { from: dayStart, to: dayEnd }
+/**
+ * Analytics over chats: the Total method with direction and Chat Tags filters, and Chat Tags grouping.
+ *
+ * Provisions its own throwaway tenant: every assertion here is an org-wide count over today's chats
+ * (totals of 3, 2 and 1), so on the shared fixture any other suite that creates a chat today makes
+ * these numbers wrong — the per-record cleanup could not prevent that, because the counts are read
+ * while the other suite's records still exist.
+ */
+export const chats_analytics_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 {
+    tenant = await setup_isolated_tenant({
+      name: `Chats analytics ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    const testEnduser = await sdk.api.endusers.createOne({
+      fname: 'ChatsAnalytics',
+      lname: 'TestUser',
+      email: `chats-analytics-test-${RAND()}@example.com`,
+    })
+
+    const chatRoom = await sdk.api.chat_rooms.createOne({
+      enduserIds: [testEnduser.id],
+    })
+
+    // Inbound chat (senderId === enduserId), tagged with 'tag-a'
+    await sdk.api.chats.createOne({
+      roomId: chatRoom.id,
+      message: "Inbound message from enduser",
+      senderId: testEnduser.id,
+      enduserId: testEnduser.id,
+      tags: ['tag-a'],
+    })
+
+    // Outbound chat (senderId !== enduserId), tagged with 'tag-b'
+    await sdk.api.chats.createOne({
+      roomId: chatRoom.id,
+      message: "Outbound message from provider",
+      senderId: sdk.userInfo.id,
+      enduserId: testEnduser.id,
+      tags: ['tag-b'],
+    })
+
+    // Inbound chat with both tags
+    await sdk.api.chats.createOne({
+      roomId: chatRoom.id,
+      message: "Inbound message with both tags",
+      senderId: testEnduser.id,
+      enduserId: testEnduser.id,
+      tags: ['tag-a', 'tag-b'],
+    })
+
+    await wait(undefined, 1000)
+
+    const now = new Date()
+    const dayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate())
+    const dayEnd = new Date(dayStart.getTime() + 24 * 60 * 60 * 1000)
+
+    const baseQuery = {
+      resource: 'Chats' as const,
+      info: { method: 'Total' as const, parameters: undefined },
+      range: { interval: 'Daily' as const, key: 'Created At' as const },
+    }
+    const createdRange = { from: dayStart, to: dayEnd }
+
     // Test 1: Total count with no filter
-    await async_test(
-      "Chats analytics - total count (no filter)",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: { ...baseQuery },
         createdRange,
-      }),
-      { onResult: r => totalFromValues(r) === 3 }
-    )
+      })
+      record(
+        "Chats analytics - total count (no filter)",
+        totalFromValues(result) === 3,
+        `total=${totalFromValues(result)} (want 3) values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
 
     // Test 2: Direction = Inbound (senderId === enduserId)
-    await async_test(
-      "Chats analytics - direction Inbound",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: { ...baseQuery, filter: { direction: 'Inbound' } },
         createdRange,
-      }),
-      { onResult: r => totalFromValues(r) === 2 }
-    )
+      })
+      record(
+        "Chats analytics - direction Inbound",
+        totalFromValues(result) === 2,
+        `total=${totalFromValues(result)} (want 2) values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
 
     // Test 3: Direction = Outbound (senderId !== enduserId)
-    await async_test(
-      "Chats analytics - direction Outbound",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: { ...baseQuery, filter: { direction: 'Outbound' } },
         createdRange,
-      }),
-      { onResult: r => totalFromValues(r) === 1 }
-    )
+      })
+      record(
+        "Chats analytics - direction Outbound",
+        totalFromValues(result) === 1,
+        `total=${totalFromValues(result)} (want 1) values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
 
     // Test 4: Chat Tags - One Of qualifier
-    await async_test(
-      "Chats analytics - Chat Tags One Of",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: { ...baseQuery, filter: { 'Chat Tags': { qualifier: 'One Of', values: ['tag-a'] } } },
         createdRange,
-      }),
-      { onResult: r => totalFromValues(r) === 2 }
-    )
+      })
+      record(
+        "Chats analytics - Chat Tags One Of",
+        totalFromValues(result) === 2,
+        `total=${totalFromValues(result)} (want 2) values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
 
     // Test 5: Chat Tags - All Of qualifier
-    await async_test(
-      "Chats analytics - Chat Tags All Of",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: { ...baseQuery, filter: { 'Chat Tags': { qualifier: 'All Of', values: ['tag-a', 'tag-b'] } } },
         createdRange,
-      }),
-      { onResult: r => totalFromValues(r) === 1 }
-    )
+      })
+      record(
+        "Chats analytics - Chat Tags All Of",
+        totalFromValues(result) === 1,
+        `total=${totalFromValues(result)} (want 1) values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
 
     // Test 6: Combined direction + tags filter
-    await async_test(
-      "Chats analytics - Inbound + Chat Tags",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: {
           ...baseQuery,
           filter: {
@@ -129,48 +163,52 @@ export const chats_analytics_tests = async ({ sdk, sdkNonAdmin } : { sdk: Sessio
           },
         },
         createdRange,
-      }),
-      { onResult: r => totalFromValues(r) === 1 }
-    )
+      })
+      record(
+        "Chats analytics - Inbound + Chat Tags",
+        totalFromValues(result) === 1,
+        `total=${totalFromValues(result)} (want 1) values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
 
     // Test 7: Chat Tags grouping
-    await async_test(
-      "Chats analytics - Chat Tags grouping",
-      () => sdk.api.analytics_frames.get_result_for_query({
+    {
+      const result = await sdk.api.analytics_frames.get_result_for_query({
         query: { ...baseQuery, grouping: { 'Chat Tags': true, Enduser: '' } },
         createdRange,
-      }),
-      { onResult: r => {
-        if (!r.values?.length) return false
-        // Grouping by tags returns entries keyed by the full tags array on each chat
-        // We expect entries for each unique tag combination, with total values summing to 3
-        const total = r.values.reduce((sum, v) => sum + v.value, 0)
-        const hasGroupKeys = r.values.some(v => v.key !== undefined)
-        return total === 3 && hasGroupKeys
-      }}
-    )
-
-    console.log("All chats analytics tests passed")
+      })
+      // Grouping by tags returns entries keyed by the full tags array on each chat
+      // We expect entries for each unique tag combination, with total values summing to 3
+      const total = totalFromValues(result)
+      const hasGroupKeys = !!result.values?.length && result.values.some(v => v.key !== undefined)
+      record(
+        "Chats analytics - Chat Tags grouping",
+        total === 3 && hasGroupKeys,
+        `total=${total} (want 3) hasGroupKeys=${hasGroupKeys} values=${JSON.stringify(result.values ?? null)}`,
+      )
+    }
   } finally {
-    await sdk.api.chats.deleteOne(inboundChat.id)
-    await sdk.api.chats.deleteOne(outboundChat.id)
-    await sdk.api.chats.deleteOne(bothTagsChat.id)
-    await sdk.api.chat_rooms.deleteOne(chatRoom.id)
-    await sdk.api.endusers.deleteOne(testEnduser.id)
+    // 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
 }
 
-if (require.main === module) {
-  console.log(`Using API URL: ${host}`)
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const chats_analytics_tests = async () => {
+  assert_checks('Chats analytics', await chats_analytics_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await chats_analytics_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Chats analytics',
+  run: chats_analytics_checks,
+}
 
-  runTests()
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  chats_analytics_tests()
     .then(() => {
       console.log("Chats analytics test suite completed successfully")
       process.exit(0)

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

@@ -1,103 +1,114 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  assert,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-export const concurrent_build_threads_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Concurrent Build Threads Test")
-
-  const timestamp = Date.now()
-  const from = new Date(Date.now() - 1000 * 60 * 60) // 1 hour ago
-
-  // Create a test enduser with a phone number
-  const testEnduser = await sdk.api.endusers.createOne({
-    fname: "ConcurrentTest",
-    lname: "Patient",
-    email: `concurrent-test-${timestamp}@test.com`,
-    phone: "+15555550101",
-  })
-
-  const phoneNumber = "+15555550102"
-  const enduserPhoneNumber = "+15555550101"
-
-  // Create a test SMS message for the enduser
-  const sms = await sdk.api.sms_messages.createOne({
-    enduserId: testEnduser.id,
-    phoneNumber,
-    enduserPhoneNumber,
-    message: 'Test message for concurrent build test',
-    inbound: true,
-    logOnly: true,
-  })
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Regression coverage for concurrent autobuild of inbox threads: three simultaneous
+ * `load_threads({ autobuild: true })` requests must leave exactly ONE SMS thread for a patient with
+ * one SMS message, not one per request.
+ *
+ * `setup_isolated_tenant` rather than `setup_tests` because the scenario needs `reset_threads()`,
+ * which is scoped to `req.session.businessId`: on the shared fixture org that wiped and rebuilt
+ * every thread in it (three times over), which is both slow and hostile to every other inbox suite.
+ * On a provisioned tenant the same call clears only the two records this suite creates.
+ *
+ * Ordering matters: autobuild bootstraps a two-week window and `build_threads` matches SMS by `_id`
+ * time range, so the enduser and the SMS are created BEFORE the first `load_threads` call.
+ *
+ * On a near-empty tenant the first build can finish before the other two requests reach the lock,
+ * in which case they rebuild the same window for real instead of short-circuiting on `alreadyBuilt`.
+ * Exactly one thread must survive either way — the assertion is not relaxed to fit one of them.
+ */
+export const concurrent_build_threads_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 {
-    // Reset threads first to ensure clean state
+    // only the admin session is used — reset_threads is adminOnly
+    tenant = await setup_isolated_tenant({
+      name: `ConcurrentBuildThreads ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    const timestamp = Date.now()
+    const phoneNumber = "+15555550102"
+    const enduserPhoneNumber = "+15555550101"
+
+    const testEnduser = await sdk.api.endusers.createOne({
+      fname: "ConcurrentTest",
+      lname: "Patient",
+      email: `concurrent-test-${timestamp}-${RAND()}@test.com`,
+      phone: enduserPhoneNumber,
+    })
+
+    await sdk.api.sms_messages.createOne({
+      enduserId: testEnduser.id,
+      phoneNumber,
+      enduserPhoneNumber,
+      message: 'Test message for concurrent build test',
+      inbound: true,
+      logOnly: true,
+    })
+
+    // clean slate for this tenant's threads
     await sdk.api.inbox_threads.reset_threads()
 
-    // Fire 3 concurrent load_threads requests with autobuild: true
-    console.log("Firing 3 concurrent load_threads requests with autobuild: true...")
-    const results = await Promise.all([
+    await Promise.all([
       sdk.api.inbox_threads.load_threads({ autobuild: true }),
       sdk.api.inbox_threads.load_threads({ autobuild: true }),
       sdk.api.inbox_threads.load_threads({ autobuild: true }),
     ])
 
-    // Also fetch all threads to see if duplicates were created
     const allThreadsResult = await sdk.api.inbox_threads.load_threads({})
-    const allThreads = allThreadsResult.threads
-
-    // Filter for threads belonging to our test enduser
-    const enduserThreads = allThreads.filter(t =>
+    const enduserThreads = allThreadsResult.threads.filter(t =>
       t.enduserIds?.includes(testEnduser.id) && t.type === 'SMS'
     )
 
-    console.log(`Found ${enduserThreads.length} SMS threads for test enduser`)
-
-    // Assert: should only have 1 thread, not duplicates
-    assert(
+    record(
+      '1: three concurrent autobuilds create exactly one SMS thread, not duplicates',
       enduserThreads.length === 1,
-      `Expected 1 SMS thread for enduser, found ${enduserThreads.length}. ` +
-      `Thread IDs: ${enduserThreads.map(t => t.id).join(', ')}`
+      `Expected 1 SMS thread for enduser, found ${enduserThreads.length}. `
+      + `Thread IDs: ${enduserThreads.map(t => t.id).join(', ')}`,
     )
-
-    console.log("✅ Concurrent build test passed - no duplicate threads created")
   } finally {
-    // Cleanup
-    console.log("Cleaning up test data...")
-    await sdk.api.sms_messages.deleteOne(sms.id)
-    await sdk.api.endusers.deleteOne(testEnduser.id)
-    // Clean up any threads created for this enduser
-    const cleanupThreads = await sdk.api.inbox_threads.load_threads({})
-    for (const thread of cleanupThreads.threads) {
-      if (thread.enduserIds?.includes(testEnduser.id)) {
-        await sdk.api.inbox_threads.deleteOne(thread.id)
-      }
-    }
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand the tenant.
+    if (tenant) { try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) } }
   }
+
+  return checks
 }
 
-if (require.main === module) {
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const concurrent_build_threads_tests = async () => {
+  assert_checks('Concurrent build threads', await concurrent_build_threads_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await concurrent_build_threads_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Concurrent build threads', run: concurrent_build_threads_checks }
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  concurrent_build_threads_tests()
     .then(() => {
-      console.log("✅ Concurrent build threads test completed")
+      console.log("✅ Concurrent build threads test suite completed successfully")
       process.exit(0)
     })
     .catch((error) => {
-      console.error("❌ Concurrent build threads test failed:", error)
+      console.error("❌ Concurrent build threads test suite failed:", error)
       process.exit(1)
     })
 }