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

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

@@ -1,14 +1,24 @@
 require('source-map-support').install();
 
-import { Session, EnduserSession } from "../../sdk"
+import { EnduserSession } from "../../sdk"
 import {
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests, authenticate_enduser_via_token } from "../setup"
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
-const businessId = process.env.TEST_BUSINESS_ID || '60398b1131a295e64f084ff6'
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+const ELATION_REFERENCE = { type: 'Elation', id: 'elation-appointment-123' }
+
+const has_only_the_elation_reference = (references: { type: string, id: string }[] | undefined) => (
+  references?.length === 1
+  && references[0].type === ELATION_REFERENCE.type
+  && references[0].id === ELATION_REFERENCE.id
+)
 
 /**
  * CU-86e2dvrn9: calendar_events.references switched from updatesDisabled to
@@ -17,21 +27,34 @@ const businessId = process.env.TEST_BUSINESS_ID || '60398b1131a295e64f084ff6'
  *     external appointment IDs like stale Elation references)
  *   - enduser (patient) sessions remain blocked — required because endusers DO
  *     have update access on calendar_events they attend (for cancelling)
+ *
+ * The enduser must stay an attendee of the event: enduser access to calendar_events is the
+ * `attendees.id` filter constraint, so an event without them returns 404 and the rejection check
+ * would pass for the wrong reason.
+ *
+ * This suite provisions its own throwaway tenant and tears it down in a finally; it never asserts
+ * inside `run`, so it is safe to run concurrently in the discovered pool.
  */
-export const calendar_event_references_update_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Calendar Event References Update (enduserUpdatesDisabled)")
+export const calendar_event_references_update_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  let enduserId: string | undefined
-  let eventId: string | undefined
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Calendar event references ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     // Setup: enduser attending a calendar event, so the enduser session has update access to it
     const enduser = await sdk.api.endusers.createOne({
-      email: `references-update-${Date.now()}@example.com`,
+      email: `references-update-${RAND()}@tellescope.example`,
       fname: 'References',
       lname: 'UpdateTest',
     })
-    enduserId = enduser.id
 
     const event = await sdk.api.calendar_events.createOne({
       title: "References Update Test Event",
@@ -39,64 +62,84 @@ export const calendar_event_references_update_tests = async ({ sdk } : { sdk: Se
       startTimeInMS: Date.now(),
       attendees: [{ id: enduser.id, type: 'enduser' }],
     })
-    eventId = event.id
 
-    const enduserSDK = new EnduserSession({ host, businessId })
-    await authenticate_enduser_via_token(sdk, enduserSDK, { id: enduser.id })
+    const { authToken } = await sdk.api.endusers.generate_auth_token({ id: enduser.id })
+    const enduserSession = new EnduserSession({ host, authToken, businessId: tenant.businessId })
+    await enduserSession.refresh_session()
 
-    // ---- Staff/API session can update references ----
-    const staffReferences = [{ type: 'Elation', id: 'elation-appointment-123' }]
-    await async_test(
-      'staff can update calendar_events.references',
-      () => sdk.api.calendar_events.updateOne(event.id, { references: staffReferences }),
-      { onResult: e => e.references?.length === 1 && e.references[0].type === 'Elation' && e.references[0].id === 'elation-appointment-123' },
+    /* ---- Staff/API session can update references ---- */
+
+    const staffUpdated = await sdk.api.calendar_events.updateOne(event.id, { references: [ELATION_REFERENCE] })
+    record(
+      'A: staff can update calendar_events.references',
+      has_only_the_elation_reference(staffUpdated.references),
+      `references=${JSON.stringify(staffUpdated.references)}`,
     )
-    await async_test(
-      'staff references update persisted',
-      () => sdk.api.calendar_events.getOne(event.id),
-      { onResult: e => e.references?.length === 1 && e.references[0].type === 'Elation' && e.references[0].id === 'elation-appointment-123' },
+
+    const afterStaffUpdate = await sdk.api.calendar_events.getOne(event.id)
+    record(
+      'B: staff references update persisted',
+      has_only_the_elation_reference(afterStaffUpdate.references),
+      `references=${JSON.stringify(afterStaffUpdate.references)}`,
     )
 
-    // ---- Enduser session (attendee with update access) is still blocked on references ----
-    await async_test(
-      'enduser cannot update calendar_events.references',
-      () => enduserSDK.api.calendar_events.updateOne(event.id, { references: [{ type: 'Attacker', id: 'attacker-reference' }] } as any),
-      { shouldError: true, onError: e => e.message === "references cannot be updated by endusers" },
+    /* ---- Enduser session (attendee with update access) is still blocked on references ---- */
+
+    let enduserUpdateError = ''
+    let enduserUpdateAccepted = false
+    try {
+      await enduserSession.api.calendar_events.updateOne(
+        event.id,
+        { references: [{ type: 'Attacker', id: 'attacker-reference' }] } as any,
+      )
+      enduserUpdateAccepted = true
+    } catch (err: any) { enduserUpdateError = err?.message ?? String(err) }
+    record(
+      'C: enduser cannot update calendar_events.references',
+      !enduserUpdateAccepted && enduserUpdateError === "references cannot be updated by endusers",
+      enduserUpdateAccepted
+        ? 'no error — the write was ACCEPTED'
+        : `error=${JSON.stringify(enduserUpdateError)}`,
     )
-    await async_test(
-      'rejected enduser references update did not persist',
-      () => sdk.api.calendar_events.getOne(event.id),
-      { onResult: e => e.references?.length === 1 && e.references[0].type === 'Elation' && e.references[0].id === 'elation-appointment-123' },
+
+    const afterEnduserUpdate = await sdk.api.calendar_events.getOne(event.id)
+    record(
+      'D: rejected enduser references update did not persist',
+      has_only_the_elation_reference(afterEnduserUpdate.references),
+      `references=${JSON.stringify(afterEnduserUpdate.references)}`,
     )
 
-    // ---- Positive control: the guard is field-scoped — enduser can still cancel the event ----
-    await async_test(
-      'enduser can still perform allowed update (cancelledAt)',
-      () => enduserSDK.api.calendar_events.updateOne(event.id, { cancelledAt: new Date() }),
-      { onResult: e => !!e.cancelledAt },
+    /* ---- Positive control: the guard is field-scoped — enduser can still cancel the event ---- */
+
+    const cancelled = await enduserSession.api.calendar_events.updateOne(event.id, { cancelledAt: new Date() })
+    record(
+      'E: enduser can still perform allowed update (cancelledAt)',
+      !!cancelled.cancelledAt,
+      `cancelledAt=${JSON.stringify(cancelled.cancelledAt)}`,
     )
   } finally {
-    if (eventId) {
-      try { await sdk.api.calendar_events.deleteOne(eventId) } catch {}
-    }
-    if (enduserId) {
-      try { await sdk.api.endusers.deleteOne(enduserId) } 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
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const calendar_event_references_update_tests = async () => {
+  assert_checks('Calendar event references enduser guard', await calendar_event_references_update_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Calendar event references enduser guard',
+  run: calendar_event_references_update_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 calendar_event_references_update_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  calendar_event_references_update_tests()
     .then(() => {
       console.log("✅ Calendar event references update test suite completed successfully")
       process.exit(0)

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

@@ -1,15 +1,18 @@
 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 HEALTHIE_TITLE = 'Healthie' // mirror @tellescope/constants HEALTHIE_TITLE
 
 // Unreachable webhook target — the request will fail quickly but the API still writes
@@ -27,172 +30,209 @@ const find_log_for_url = async (sdk: Session, url: string, expectedHealthieId: s
   return null
 }
 
-// Main test function that can be called independently
-export const calendar_event_webhook_template_tests = async (
-  { sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }
-) => {
-  log_header("Calendar Event Webhook Template Tests")
-
-  const enduser = await sdk.api.endusers.createOne({})
-
-  // Case 1: Healthie ID resolved via source + externalId
-  const externalIdEvent = await sdk.api.calendar_events.createOne({
-    title: 'External ID Calendar Event',
-    durationInMinutes: 30,
-    startTimeInMS: Date.now(),
-    attendees: [{ type: 'enduser', id: enduser.id }],
-    source: HEALTHIE_TITLE,
-    externalId: 'evt_HEALTHIE_123',
-  } as any)
-
-  // Case 2: Healthie ID resolved via references
-  const referencesEvent = await sdk.api.calendar_events.createOne({
-    title: 'References Calendar Event',
-    durationInMinutes: 30,
-    startTimeInMS: Date.now(),
-    attendees: [{ type: 'enduser', id: enduser.id }],
-    references: [{ type: HEALTHIE_TITLE, id: 'evt_REF_456' }],
-  } as any)
-
-  // create an automation step to satisfy schema validation (automationStepId is required)
-  const journey = await sdk.api.journeys.createOne({
-    title: 'Calendar Event Webhook Template Tests',
-    defaultState: 'State 1',
-  })
-  const step = await sdk.api.automation_steps.createOne({
-    journeyId: journey.id,
-    events: [{ type: 'onJourneyStart', info: {} }],
-    action: {
-      type: 'sendWebhook',
-      info: {
-        message: 'placeholder',
-        url: WEBHOOK_TARGET_URL,
-      },
-    },
-  })
+/**
+ * Covers {{calendar_event.*}} placeholder resolution in a sendWebhook action: the Healthie ID
+ * resolved from source+externalId and from references, and left verbatim when no calendar event is
+ * in context.
+ *
+ * Provisions its own throwaway tenant: the delivery is found by scanning the 50 most recent
+ * `webhook_logs` business-wide, so on the shared fixture another suite's webhook traffic can push
+ * the log under test out of the window before it is read.
+ */
+export const calendar_event_webhook_template_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
+  let enduserId: string | undefined
+  let externalIdEventId: string | undefined
+  let referencesEventId: string | undefined
+  let journeyId: string | undefined
+  let stepId: string | undefined
 
   try {
-    await async_test(
-      'Send Webhook resolves {{calendar_event.Healthie ID}} from source+externalId',
-      async () => {
-        const url = `${WEBHOOK_TARGET_URL}/external/${externalIdEvent.id}`
-        await sdk.api.webhooks.send_automation_webhook({
+    tenant = await setup_isolated_tenant({
+      name: `Calendar event webhook template ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    const enduser = await sdk.api.endusers.createOne({})
+    enduserId = enduser.id
+
+    // Case 1: Healthie ID resolved via source + externalId
+    const externalIdEvent = await sdk.api.calendar_events.createOne({
+      title: 'External ID Calendar Event',
+      durationInMinutes: 30,
+      startTimeInMS: Date.now(),
+      attendees: [{ type: 'enduser', id: enduser.id }],
+      source: HEALTHIE_TITLE,
+      externalId: 'evt_HEALTHIE_123',
+    } as any)
+    externalIdEventId = externalIdEvent.id
+
+    // Case 2: Healthie ID resolved via references
+    const referencesEvent = await sdk.api.calendar_events.createOne({
+      title: 'References Calendar Event',
+      durationInMinutes: 30,
+      startTimeInMS: Date.now(),
+      attendees: [{ type: 'enduser', id: enduser.id }],
+      references: [{ type: HEALTHIE_TITLE, id: 'evt_REF_456' }],
+    } as any)
+    referencesEventId = referencesEvent.id
+
+    // create an automation step to satisfy schema validation (automationStepId is required)
+    const journey = await sdk.api.journeys.createOne({
+      title: 'Calendar Event Webhook Template Tests',
+      defaultState: 'State 1',
+    })
+    journeyId = journey.id
+    const step = await sdk.api.automation_steps.createOne({
+      journeyId: journey.id,
+      events: [{ type: 'onJourneyStart', info: {} }],
+      action: {
+        type: 'sendWebhook',
+        info: {
           message: 'placeholder',
-          enduserId: enduser.id,
-          automationStepId: step.id,
-          action: {
-            type: 'sendWebhook',
-            info: {
-              message: 'placeholder',
-              url,
-              fields: [
-                { field: 'healthieId', value: '{{calendar_event.Healthie ID}}' },
-                { field: 'title', value: '{{calendar_event.title}}' },
-              ],
-            },
-          },
-          context: { calendarEventId: externalIdEvent.id },
-        }).catch(() => {}) // the unreachable URL is expected to error after logging
-
-        const log = await find_log_for_url(sdk, url, 'evt_HEALTHIE_123')
-        if (!log) return false
-        const payload = log.payload as any
-        return payload?.healthieId === 'evt_HEALTHIE_123'
-          && payload?.title === externalIdEvent.title
+          url: WEBHOOK_TARGET_URL,
+        },
       },
-      { onResult: r => r === true }
-    )
-
-    await async_test(
-      'Send Webhook resolves {{calendar_event.Healthie ID}} from references',
-      async () => {
-        const url = `${WEBHOOK_TARGET_URL}/refs/${referencesEvent.id}`
-        await sdk.api.webhooks.send_automation_webhook({
-          message: 'placeholder',
-          enduserId: enduser.id,
-          automationStepId: step.id,
-          action: {
-            type: 'sendWebhook',
-            info: {
-              message: 'placeholder',
-              url,
-              fields: [
-                { field: 'healthieId', value: '{{calendar_event.Healthie ID}}' },
-                { field: 'title', value: '{{calendar_event.title}}' },
-              ],
-            },
+    })
+    stepId = step.id
+
+    {
+      const url = `${WEBHOOK_TARGET_URL}/external/${externalIdEvent.id}`
+      await sdk.api.webhooks.send_automation_webhook({
+        message: 'placeholder',
+        enduserId: enduser.id,
+        automationStepId: step.id,
+        action: {
+          type: 'sendWebhook',
+          info: {
+            message: 'placeholder',
+            url,
+            fields: [
+              { field: 'healthieId', value: '{{calendar_event.Healthie ID}}' },
+              { field: 'title', value: '{{calendar_event.title}}' },
+            ],
           },
-          context: { calendarEventId: referencesEvent.id },
-        }).catch(() => {})
-
-        const log = await find_log_for_url(sdk, url, 'evt_REF_456')
-        if (!log) return false
-        const payload = log.payload as any
-        return payload?.healthieId === 'evt_REF_456'
-          && payload?.title === referencesEvent.title
-      },
-      { onResult: r => r === true }
-    )
-
-    await async_test(
-      'Send Webhook leaves {{calendar_event.Healthie ID}} blank when no calendarEventId in context',
-      async () => {
-        const url = `${WEBHOOK_TARGET_URL}/nocontext`
-        await sdk.api.webhooks.send_automation_webhook({
-          message: 'placeholder',
-          enduserId: enduser.id,
-          automationStepId: step.id,
-          action: {
-            type: 'sendWebhook',
-            info: {
-              message: 'placeholder',
-              url,
-              fields: [
-                { field: 'healthieId', value: '{{calendar_event.Healthie ID}}' },
-              ],
-            },
+        },
+        context: { calendarEventId: externalIdEvent.id },
+      }).catch(() => {}) // the unreachable URL is expected to error after logging
+
+      const log = await find_log_for_url(sdk, url, 'evt_HEALTHIE_123')
+      const payload = log?.payload as any
+      record(
+        'Send Webhook resolves {{calendar_event.Healthie ID}} from source+externalId',
+        !!log
+        && payload?.healthieId === 'evt_HEALTHIE_123'
+        && payload?.title === externalIdEvent.title,
+        log ? `payload=${JSON.stringify(payload)}` : 'no webhook_log written for the URL within 10s',
+      )
+    }
+
+    {
+      const url = `${WEBHOOK_TARGET_URL}/refs/${referencesEvent.id}`
+      await sdk.api.webhooks.send_automation_webhook({
+        message: 'placeholder',
+        enduserId: enduser.id,
+        automationStepId: step.id,
+        action: {
+          type: 'sendWebhook',
+          info: {
+            message: 'placeholder',
+            url,
+            fields: [
+              { field: 'healthieId', value: '{{calendar_event.Healthie ID}}' },
+              { field: 'title', value: '{{calendar_event.title}}' },
+            ],
           },
-          // no calendarEventId
-        }).catch(() => {})
-
-        // Without a calendar event in context, the templating helper returns the input
-        // unchanged, so the literal template string remains in the payload.
-        const start = Date.now()
-        while (Date.now() - start < 10_000) {
-          const logs = await sdk.api.webhook_logs.getSome({ limit: 50, sort: 'newFirst' as any }) as Array<any>
-          const match = logs.find(l => l.url === url)
-          if (match) {
-            const payload = match.payload as any
-            return payload?.healthieId === '{{calendar_event.Healthie ID}}'
-          }
-          await wait(undefined, 500)
-        }
-        return false
-      },
-      { onResult: r => r === true }
-    )
-
+        },
+        context: { calendarEventId: referencesEvent.id },
+      }).catch(() => {})
+
+      const log = await find_log_for_url(sdk, url, 'evt_REF_456')
+      const payload = log?.payload as any
+      record(
+        'Send Webhook resolves {{calendar_event.Healthie ID}} from references',
+        !!log
+        && payload?.healthieId === 'evt_REF_456'
+        && payload?.title === referencesEvent.title,
+        log ? `payload=${JSON.stringify(payload)}` : 'no webhook_log written for the URL within 10s',
+      )
+    }
+
+    {
+      const url = `${WEBHOOK_TARGET_URL}/nocontext`
+      await sdk.api.webhooks.send_automation_webhook({
+        message: 'placeholder',
+        enduserId: enduser.id,
+        automationStepId: step.id,
+        action: {
+          type: 'sendWebhook',
+          info: {
+            message: 'placeholder',
+            url,
+            fields: [
+              { field: 'healthieId', value: '{{calendar_event.Healthie ID}}' },
+            ],
+          },
+        },
+        // no calendarEventId
+      }).catch(() => {})
+
+      // Without a calendar event in context, the templating helper returns the input
+      // unchanged, so the literal template string remains in the payload.
+      let match: any = null
+      const start = Date.now()
+      while (Date.now() - start < 10_000) {
+        const logs = await sdk.api.webhook_logs.getSome({ limit: 50, sort: 'newFirst' as any }) as Array<any>
+        match = logs.find(l => l.url === url) ?? null
+        if (match) break
+        await wait(undefined, 500)
+      }
+
+      const payload = match?.payload as any
+      record(
+        'Send Webhook leaves {{calendar_event.Healthie ID}} blank when no calendarEventId in context',
+        !!match && payload?.healthieId === '{{calendar_event.Healthie ID}}',
+        match ? `payload=${JSON.stringify(payload)}` : 'no webhook_log written for the URL within 10s',
+      )
+    }
   } finally {
-    try { await sdk.api.calendar_events.deleteOne(externalIdEvent.id) } catch {}
-    try { await sdk.api.calendar_events.deleteOne(referencesEvent.id) } catch {}
-    try { await sdk.api.automation_steps.deleteOne(step.id) } catch {}
-    try { await sdk.api.journeys.deleteOne(journey.id) } catch {}
-    try { await sdk.api.endusers.deleteOne(enduser.id) } catch {}
+    if (tenant) {
+      const { sdk } = tenant
+      // The per-record deletes teardown would also cover, kept so the diff stays a migration rather
+      // than a rewrite. Each is caught so a failing delete can never skip the teardown below.
+      if (externalIdEventId) await sdk.api.calendar_events.deleteOne(externalIdEventId).catch(() => {})
+      if (referencesEventId) await sdk.api.calendar_events.deleteOne(referencesEventId).catch(() => {})
+      if (stepId) await sdk.api.automation_steps.deleteOne(stepId).catch(() => {})
+      if (journeyId) await sdk.api.journeys.deleteOne(journeyId).catch(() => {})
+      if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(() => {})
+      // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+      try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) }
+    }
   }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const calendar_event_webhook_template_tests = async () => {
+  assert_checks('Calendar event webhook template', await calendar_event_webhook_template_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Calendar event webhook template',
+  run: calendar_event_webhook_template_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 calendar_event_webhook_template_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  calendar_event_webhook_template_tests()
     .then(() => {
       console.log("✅ Calendar event webhook template test suite completed successfully")
       process.exit(0)