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

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

@@ -0,0 +1,220 @@
+require('source-map-support').install();
+
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * The backend contract behind the Journey editor's manual per-step count.
+ *
+ * When the journey statistics aggregation cannot produce numbers, a step node offers a "Get count"
+ * link that counts that one step through the ORDINARY automated_actions read — no new endpoint:
+ *
+ *     automated_actions.getSome({ returnCount: true, filter: { automationStepId } })
+ *     automated_actions.getSome({ returnCount: true, filter: { automationStepId, status: 'finished' } })
+ *
+ * Two properties the UI depends on and that nothing else covers:
+ *
+ *   1. `returnCount` resolves to `{ count }` (not a list), and `filter` is actually applied to the
+ *      count — `queries.count` takes a different code path from `findPage`, so "the filter is
+ *      honoured" is a real assertion, not a tautology. A count that ignored `filter` would silently
+ *      report the whole tenant's automated_actions on every step.
+ *   2. The count is session-scoped the same way the list read is, so it equals the number of rows
+ *      the step drawer lists for that same session. This is what makes a lower number for a
+ *      restricted user correct rather than a bug — and it is asserted by comparing the count with
+ *      the rows, for an admin and for a non-admin, rather than by hardcoding either access level.
+ *
+ * `setup_isolated` because every assertion here is an exact count over a whole businessId
+ * partition; on the shared org, other journey suites leave automated_actions behind.
+ *
+ * automated_actions are seeded directly rather than by driving a real journey: the counts are what
+ * is under test, and seeding makes the expected numbers exact and the run fast. `processAfter` is
+ * far in the future so the worker cannot process (and so mutate) them mid-assertion.
+ */
+export const journey_step_manual_count_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: `JourneyStepManualCount ${RAND()}`,
+      users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+      apiKeys: 0,
+    })
+    const { sdk, sdkNonAdmin } = tenant
+
+    /* ================= fixtures ================= */
+
+    const journey = await sdk.api.journeys.createOne({ title: `Manual Count ${RAND()}` })
+
+    const makeStep = (status: string) => sdk.api.automation_steps.createOne({
+      journeyId: journey.id,
+      action: { type: 'setEnduserStatus', info: { status } },
+      events: [{ type: 'onJourneyStart', info: {} }],
+    })
+    // counted, a second step to prove the filter discriminates, and one that is never entered
+    const [countedStep, otherStep, emptyStep] = await Promise.all([
+      makeStep('Counted'), makeStep('Other'), makeStep('Empty'),
+    ])
+
+    const enduser = await sdk.api.endusers.createOne({
+      fname: 'Manual', lname: 'Count', email: `dontsend-manual-count-${RAND()}@tellescope.com`,
+    })
+
+    const seed = (automationStepId: string, status: 'finished' | 'active' | 'cancelled' | 'error') => (
+      sdk.api.automated_actions.createOne({
+        journeyId: journey.id,
+        automationStepId,
+        enduserId: enduser.id,
+        processAfter: Date.now() + 1000000,
+        status,
+        event: { type: 'onJourneyStart', info: {} },
+        action: { type: 'setEnduserStatus', info: { status: 'Counted' } },
+      })
+    )
+
+    // countedStep: 3 finished, 2 active, 1 cancelled, 1 error => total 7, finished 3.
+    // The non-finished statuses matter: the UI shows Total and Finished only, so a count that
+    // quietly excluded cancelled/error rows would still look plausible with a simpler fixture.
+    await Promise.all([
+      seed(countedStep.id, 'finished'), seed(countedStep.id, 'finished'), seed(countedStep.id, 'finished'),
+      seed(countedStep.id, 'active'), seed(countedStep.id, 'active'),
+      seed(countedStep.id, 'cancelled'),
+      seed(countedStep.id, 'error'),
+      // a second step, so a filter that was dropped would report 9 rather than 7
+      seed(otherStep.id, 'finished'), seed(otherStep.id, 'active'),
+    ])
+
+    /* ================= helpers ================= */
+
+    // getSome is typed Promise<T[]>, but a returnCount read resolves to { count }
+    const count_for = async (session: typeof sdk, automationStepId: string, status?: string) => (
+      await session.api.automated_actions.getSome({
+        returnCount: true,
+        filter: { automationStepId, ...(status ? { status } : { }) } as any,
+      }) as unknown as { count?: number }
+    )
+
+    const rows_for = (session: typeof sdk, automationStepId: string, status?: string) => (
+      session.api.automated_actions.getSome({
+        limit: 100, // the step drawer's page size
+        filter: { automationStepId, ...(status ? { status } : { }) } as any,
+      })
+    )
+
+    /* ====== 1. returnCount + filter: the shape and the arithmetic ====== */
+
+    const total = await count_for(sdk, countedStep.id)
+    record(
+      '1a. returnCount resolves to { count }, not a list of records',
+      !Array.isArray(total) && typeof total?.count === 'number',
+      `response=${JSON.stringify(total)}`,
+    )
+    record(
+      '1b. the count is filtered to the step, counting every status',
+      total?.count === 7,
+      `count=${JSON.stringify(total?.count)}, expected 7 (3 finished + 2 active + 1 cancelled + 1 error)`,
+    )
+
+    const finished = await count_for(sdk, countedStep.id, 'finished')
+    record(
+      '1c. adding status: finished narrows the same count',
+      finished?.count === 3,
+      `count=${JSON.stringify(finished?.count)}, expected 3`,
+    )
+
+    // if `filter` were dropped on the count path, both steps would report the tenant-wide 9
+    const otherTotal = await count_for(sdk, otherStep.id)
+    record(
+      '1d. a different step counts separately, so the filter is genuinely applied',
+      otherTotal?.count === 2,
+      `count=${JSON.stringify(otherTotal?.count)}, expected 2 (and NOT 9, the tenant-wide total)`,
+    )
+
+    // QA step 13: a step nobody has entered is 0, not a failure
+    const emptyTotal = await count_for(sdk, emptyStep.id)
+    record(
+      '1e. a step with no automated actions counts 0 rather than erroring',
+      emptyTotal?.count === 0,
+      `count=${JSON.stringify(emptyTotal?.count)}`,
+    )
+
+    /* ====== 2. the count equals the rows the step drawer lists ====== */
+
+    const [adminRows, adminFinishedRows] = await Promise.all([
+      rows_for(sdk, countedStep.id),
+      rows_for(sdk, countedStep.id, 'finished'),
+    ])
+    record(
+      '2a. the admin count equals the rows the same session can list',
+      total?.count === adminRows.length && finished?.count === adminFinishedRows.length,
+      `count=${total?.count} vs rows=${adminRows.length};`
+      + ` finished count=${finished?.count} vs rows=${adminFinishedRows.length}`,
+    )
+
+    /* ====== 3. the count is session-scoped, the same way the list read is ====== */
+
+    // The point is NOT that a non-admin sees a particular number — that depends on the tenant's
+    // role-based access for automated_actions. It is that whatever they can READ is what they
+    // COUNT, so the number on the node always matches the drawer they open from it.
+    const [nonAdminTotal, nonAdminFinished] = await Promise.all([
+      count_for(sdkNonAdmin, countedStep.id),
+      count_for(sdkNonAdmin, countedStep.id, 'finished'),
+    ])
+    const [nonAdminRows, nonAdminFinishedRows] = await Promise.all([
+      rows_for(sdkNonAdmin, countedStep.id),
+      rows_for(sdkNonAdmin, countedStep.id, 'finished'),
+    ])
+
+    record(
+      '3a. a non-admin count equals the rows that non-admin can list',
+      nonAdminTotal?.count === nonAdminRows.length
+        && nonAdminFinished?.count === nonAdminFinishedRows.length,
+      `count=${nonAdminTotal?.count} vs rows=${nonAdminRows.length};`
+      + ` finished count=${nonAdminFinished?.count} vs rows=${nonAdminFinishedRows.length}`,
+    )
+    // a restricted session may legitimately count lower, but never higher than the admin
+    record(
+      '3b. a non-admin never counts more than the admin',
+      (nonAdminTotal?.count ?? 0) <= (total?.count ?? 0)
+        && (nonAdminFinished?.count ?? 0) <= (finished?.count ?? 0),
+      `non-admin total=${nonAdminTotal?.count} vs admin ${total?.count};`
+      + ` non-admin finished=${nonAdminFinished?.count} vs admin ${finished?.count}`,
+    )
+    record(
+      '3c. finished never exceeds the total, for either session',
+      (finished?.count ?? 0) <= (total?.count ?? 0)
+        && (nonAdminFinished?.count ?? 0) <= (nonAdminTotal?.count ?? 0),
+      `admin ${finished?.count}/${total?.count}, non-admin ${nonAdminFinished?.count}/${nonAdminTotal?.count}`,
+    )
+
+    return checks
+  } finally {
+    await tenant?.teardown()
+  }
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const journey_step_manual_count_tests = async () => {
+  assert_checks('Journey step manual count', await journey_step_manual_count_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Journey step manual count', run: journey_step_manual_count_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}`)
+
+  journey_step_manual_count_tests()
+  .then(() => { console.log("✅ Journey step manual count tests passed"); process.exit(0) })
+  .catch(error => { console.error("❌ Journey step manual count tests failed:", error); process.exit(1) })
+}

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

@@ -4,6 +4,7 @@ import {
   assert_checks,
   Check,
   setup_isolated_tenant,
+  IsolatedSuite,
 } from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
@@ -195,6 +196,9 @@ export const load_threads_care_team_tests = async () => {
   assert_checks('Load threads care team', await load_threads_care_team_checks())
 }
 
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Load threads care team', run: load_threads_care_team_checks }
+
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)

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

@@ -10,6 +10,7 @@ import {
   set_email_verification_code,
   setup_isolated_tenant,
   test_support_request,
+  IsolatedSuite,
 } from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
@@ -225,6 +226,9 @@ export const organization_signup_tests = async () => {
   assert_checks('Organization signup', await organization_signup_checks())
 }
 
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Organization signup', run: organization_signup_checks }
+
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)