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

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

@@ -1,173 +1,223 @@
 require('source-map-support').install();
 
 import axios from "axios"
-import { Session } from "../../sdk"
-import { log_header, async_test, assert } from "@tellescope/testing"
-import { setup_tests } from "../setup"
 
-const host = process.env.API_URL || "http://localhost:8080"
-
-// same seeded test API key used by formsort_tests (tests.ts)
-const TEST_API_KEY = "9d4f9dff00f60df2690a16da2cb848f289b447614ad9bef850e54af09a1fbf7a"
-// seeded second-tenant key (sdkOther in tests.ts) — valid, but for a different organization
-const OTHER_TENANT_API_KEY = "ba745e25162bb95a795c5fa1af70df188d93c4d3aac9c48b34a5c8c9dd7b80f7"
-const TEST_EMAIL = "formsort-header-auth@tellescope.com"
+import {
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
-export const formsort_header_auth_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("FormSort Header Auth Tests")
+const host = process.env.API_URL || "http://localhost:8080"
 
-  const form = await sdk.api.forms.createOne({ title: "FormSort Header Auth" })
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Auth precedence on the formsort / form-ingestion webhook.
+ *
+ * The route takes its API key from `Authorization: API_KEY <key>` when that header parses, and
+ * otherwise from the last path segment (api/v1/api.ts, parse_api_key_from_authorization_header). The
+ * nine numbered steps below pin both halves of that: the header wins when it is present and valid,
+ * every other Authorization shape falls through to the path key rather than erroring, and an invalid
+ * header key is rejected outright instead of silently falling back.
+ *
+ * Two provisioned tenants, both with `apiKeys: 0, legacyApiKeys: 1`:
+ *   - the keys MUST be legacy (plaintext `{ key }`) ones. `get_matching_api_key` matches
+ *     `{ $or: [{ key }, { hashedKey }] }`, and the hashed shape a default-provisioned `apiKeys` key
+ *     uses is a utf8 sha256 digest the webhook has no way to reproduce from the request — a hashed
+ *     key simply cannot authenticate here. This file is also the ONLY coverage of that legacy
+ *     plaintext path: scoped_api_keys.test.ts covers the scoped variant.
+ *   - the second tenant exists for step 9 only: its key authenticates, but the form belongs to the
+ *     first tenant, so the org-scoped lookup must 400 — which is what proves the HEADER key's
+ *     organization scoped the request and not the path key's.
+ *
+ * The responder_uuid values are fixed (`fha-N`) rather than randomized: the webhook short-circuits
+ * with "Already submitted" once a responder's response is finalized, so each step needs its own, and
+ * a freshly provisioned tenant per run is what keeps them from colliding between runs.
+ */
+export const formsort_header_auth_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let primary: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+  let other: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
-  const buildUrl = (route: 'formsort' | 'form-ingestion', pathSegment: string) => {
-    const url = new URL(`${host}/v1/webhooks/${route}/${pathSegment}`)
-    url.searchParams.set('formId', form.id)
-    url.searchParams.set('returnJSON', 'true')
-    return url.toString()
-  }
+  try {
+    ;[primary, other] = await Promise.all([
+      setup_isolated_tenant({
+        name: `FormSort header auth ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0, legacyApiKeys: 1,
+      }),
+      setup_isolated_tenant({
+        name: `FormSort header auth other ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0, legacyApiKeys: 1,
+      }),
+    ])
+
+    const TEST_API_KEY = primary.legacyApiKeys[0]
+    const OTHER_TENANT_API_KEY = other.legacyApiKeys[0]
+    const TEST_EMAIL = `formsort-header-auth-${RAND()}@tellescope.com`
+
+    const form = await primary.sdk.api.forms.createOne({ title: "FormSort Header Auth" })
+
+    const buildUrl = (route: 'formsort' | 'form-ingestion', pathSegment: string) => {
+      const url = new URL(`${host}/v1/webhooks/${route}/${pathSegment}`)
+      url.searchParams.set('formId', form.id)
+      url.searchParams.set('returnJSON', 'true')
+      return url.toString()
+    }
 
-  const bodyFor = (responder_uuid: string) => ({
-    answers: [{ key: 'email', value: TEST_EMAIL }],
-    responder_uuid,
-    finalized: true,
-  })
+    const bodyFor = (responder_uuid: string) => ({
+      answers: [{ key: 'email', value: TEST_EMAIL }],
+      responder_uuid,
+      finalized: true,
+    })
 
-  const formResponseIds: string[] = []
+    /** Never throws: every step wants the status/body of a rejection as evidence, not an exception. */
+    const postWebhook = async (url: string, body: object, headers: Record<string, string> = {}) => {
+      const r = await axios.post(url, body, { headers, validateStatus: () => true })
+      return { status: r.status, data: r.data }
+    }
 
-  try {
     // 1. Valid key via Authorization: API_KEY header (placeholder path segment)
-    const headerAuthResult = await axios.post(
+    const headerAuthResult = await postWebhook(
       buildUrl('formsort', 'key-in-header'),
       bodyFor("fha-1"),
-      { headers: { Authorization: `API_KEY ${TEST_API_KEY}` } },
+      { Authorization: `API_KEY ${TEST_API_KEY}` },
     )
-    assert(
-      headerAuthResult.status === 200 && !!headerAuthResult.data?.formResponseId && !!headerAuthResult.data?.enduserId,
-      `Header auth failed: ${headerAuthResult.status} ${JSON.stringify(headerAuthResult.data)}`,
+    record(
       "Valid API_KEY header authenticates",
+      headerAuthResult.status === 200 && !!headerAuthResult.data?.formResponseId && !!headerAuthResult.data?.enduserId,
+      `status=${headerAuthResult.status} body=${JSON.stringify(headerAuthResult.data)}`,
     )
-    if (headerAuthResult.data?.formResponseId) formResponseIds.push(headerAuthResult.data.formResponseId)
 
-    await async_test(
+    // 1b. ...and the record it wrote is real, in the right form, and marked submitted
+    const storedResponse = headerAuthResult.data?.formResponseId
+      ? await primary.sdk.api.form_responses.getOne(headerAuthResult.data.formResponseId)
+          .catch((e: any) => ({ error: e?.message || `${e}` }) as any)
+      : null
+    record(
       "Form response created via header auth is retrievable",
-      () => sdk.api.form_responses.getOne(headerAuthResult.data.formResponseId),
-      { onResult: fr => fr.formId === form.id && fr.source === 'Formsort' && !!fr.submittedAt },
+      !!storedResponse && !storedResponse.error
+        && storedResponse.formId === form.id && storedResponse.source === 'Formsort' && !!storedResponse.submittedAt,
+      // branch on the raw value, not on JSON.stringify of it: JSON.stringify(null) is the truthy
+      // string 'null', which would make a `|| fallback` here unreachable
+      `formResponseId=${headerAuthResult.data?.formResponseId} stored=`
+        + (storedResponse ? JSON.stringify(storedResponse) : 'not fetched — step 1 returned no formResponseId'),
     )
 
     // 2. Invalid key in header rejected, even with a valid key in the path (header takes precedence)
-    await async_test(
+    const invalidHeaderResult = await postWebhook(
+      buildUrl('formsort', TEST_API_KEY),
+      bodyFor("fha-2"),
+      { Authorization: `API_KEY not-a-real-key` },
+    )
+    record(
       "Invalid API_KEY header rejected despite valid key in path",
-      () => axios.post(
-        buildUrl('formsort', TEST_API_KEY),
-        bodyFor("fha-2"),
-        { headers: { Authorization: `API_KEY not-a-real-key` } },
-      ),
-      { shouldError: true, onError: (e: any) => e.response?.status === 401 },
+      invalidHeaderResult.status === 401,
+      `status=${invalidHeaderResult.status} (want 401) body=${JSON.stringify(invalidHeaderResult.data)}`,
     )
 
     // 3. Back-compat: valid key in path, no Authorization header
-    const pathAuthResult = await axios.post(buildUrl('formsort', TEST_API_KEY), bodyFor("fha-3"))
-    assert(
-      pathAuthResult.status === 200 && !!pathAuthResult.data?.formResponseId,
-      `Path auth failed: ${pathAuthResult.status} ${JSON.stringify(pathAuthResult.data)}`,
+    const pathAuthResult = await postWebhook(buildUrl('formsort', TEST_API_KEY), bodyFor("fha-3"))
+    record(
       "Path-segment API key still authenticates (no header)",
+      pathAuthResult.status === 200 && !!pathAuthResult.data?.formResponseId,
+      `status=${pathAuthResult.status} body=${JSON.stringify(pathAuthResult.data)}`,
     )
-    if (pathAuthResult.data?.formResponseId) formResponseIds.push(pathAuthResult.data.formResponseId)
 
     // 4. Back-compat: non-API_KEY Authorization scheme falls through to path key
-    const bearerFallthroughResult = await axios.post(
+    const bearerFallthroughResult = await postWebhook(
       buildUrl('formsort', TEST_API_KEY),
       bodyFor("fha-4"),
-      { headers: { Authorization: 'Bearer unrelated-token' } },
+      { Authorization: 'Bearer unrelated-token' },
     )
-    assert(
-      bearerFallthroughResult.status === 200 && !!bearerFallthroughResult.data?.formResponseId,
-      `Bearer fallthrough failed: ${bearerFallthroughResult.status} ${JSON.stringify(bearerFallthroughResult.data)}`,
+    record(
       "Non-API_KEY Authorization scheme falls through to path key",
+      bearerFallthroughResult.status === 200 && !!bearerFallthroughResult.data?.formResponseId,
+      `status=${bearerFallthroughResult.status} body=${JSON.stringify(bearerFallthroughResult.data)}`,
     )
-    if (bearerFallthroughResult.data?.formResponseId) formResponseIds.push(bearerFallthroughResult.data.formResponseId)
 
     // 5. No valid key in header or path
-    await async_test(
+    const noKeyResult = await postWebhook(buildUrl('formsort', 'not-a-real-key'), bodyFor("fha-5"))
+    record(
       "No valid key anywhere rejected",
-      () => axios.post(buildUrl('formsort', 'not-a-real-key'), bodyFor("fha-5")),
-      { shouldError: true, onError: (e: any) => e.response?.status === 401 },
+      noKeyResult.status === 401,
+      `status=${noKeyResult.status} (want 401) body=${JSON.stringify(noKeyResult.data)}`,
     )
 
     // 6. Alias route accepts header auth too
-    const aliasResult = await axios.post(
+    const aliasResult = await postWebhook(
       buildUrl('form-ingestion', 'key-in-header'),
       bodyFor("fha-6"),
-      { headers: { Authorization: `API_KEY ${TEST_API_KEY}` } },
+      { Authorization: `API_KEY ${TEST_API_KEY}` },
     )
-    assert(
-      aliasResult.status === 200 && !!aliasResult.data?.formResponseId,
-      `form-ingestion header auth failed: ${aliasResult.status} ${JSON.stringify(aliasResult.data)}`,
+    record(
       "form-ingestion alias accepts API_KEY header",
+      aliasResult.status === 200 && !!aliasResult.data?.formResponseId,
+      `status=${aliasResult.status} body=${JSON.stringify(aliasResult.data)}`,
     )
-    if (aliasResult.data?.formResponseId) formResponseIds.push(aliasResult.data.formResponseId)
 
     // 7. Back-compat: API_KEY scheme with no value falls through to the path key
-    const emptyValueResult = await axios.post(
+    const emptyValueResult = await postWebhook(
       buildUrl('formsort', TEST_API_KEY),
       bodyFor("fha-7"),
-      { headers: { Authorization: 'API_KEY' } },
+      { Authorization: 'API_KEY' },
     )
-    assert(
-      emptyValueResult.status === 200 && !!emptyValueResult.data?.formResponseId,
-      `Empty-value header fallthrough failed: ${emptyValueResult.status} ${JSON.stringify(emptyValueResult.data)}`,
+    record(
       "API_KEY scheme without value falls through to path key",
+      emptyValueResult.status === 200 && !!emptyValueResult.data?.formResponseId,
+      `status=${emptyValueResult.status} body=${JSON.stringify(emptyValueResult.data)}`,
     )
-    if (emptyValueResult.data?.formResponseId) formResponseIds.push(emptyValueResult.data.formResponseId)
 
     // 8. Back-compat: single-token (schemeless) Authorization header falls through to the path key
-    const singleTokenResult = await axios.post(
+    const singleTokenResult = await postWebhook(
       buildUrl('formsort', TEST_API_KEY),
       bodyFor("fha-8"),
-      { headers: { Authorization: 'some-opaque-token' } },
+      { Authorization: 'some-opaque-token' },
     )
-    assert(
-      singleTokenResult.status === 200 && !!singleTokenResult.data?.formResponseId,
-      `Single-token header fallthrough failed: ${singleTokenResult.status} ${JSON.stringify(singleTokenResult.data)}`,
+    record(
       "Schemeless Authorization header falls through to path key",
+      singleTokenResult.status === 200 && !!singleTokenResult.data?.formResponseId,
+      `status=${singleTokenResult.status} body=${JSON.stringify(singleTokenResult.data)}`,
     )
-    if (singleTokenResult.data?.formResponseId) formResponseIds.push(singleTokenResult.data.formResponseId)
 
     // 9. When header and path both hold VALID keys, the header key's organization scopes the request:
     // the formId belongs to the primary tenant, so an other-tenant header key must fail form lookup (400),
     // proving the path key's org is not used
-    await async_test(
+    const crossTenantHeaderResult = await postWebhook(
+      buildUrl('formsort', TEST_API_KEY),
+      bodyFor("fha-9"),
+      { Authorization: `API_KEY ${OTHER_TENANT_API_KEY}` },
+    )
+    record(
       "Valid other-tenant header key overrides valid path key (org scoping)",
-      () => axios.post(
-        buildUrl('formsort', TEST_API_KEY),
-        bodyFor("fha-9"),
-        { headers: { Authorization: `API_KEY ${OTHER_TENANT_API_KEY}` } },
-      ),
-      { shouldError: true, onError: (e: any) => e.response?.status === 400 && e.response?.data === 'formId Invalid' },
+      crossTenantHeaderResult.status === 400 && crossTenantHeaderResult.data === 'formId Invalid',
+      `status=${crossTenantHeaderResult.status} body=${JSON.stringify(crossTenantHeaderResult.data)}`
+        + ` (want 400 'formId Invalid'; tenants primary=${primary.businessId} other=${other.businessId})`,
     )
   } finally {
-    for (const id of formResponseIds) {
-      try { await sdk.api.form_responses.deleteOne(id) } catch (err) { /* may not exist */ }
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand these tenants
+    // permanently (nothing in the system can delete an organization record).
+    for (const t of [primary, other]) {
+      if (t) { try { await t.teardown() } catch (e) { console.error('teardown failed', e) } }
     }
-    try {
-      const enduser = await sdk.api.endusers.getOne({ email: TEST_EMAIL })
-      await sdk.api.endusers.deleteOne(enduser.id)
-    } catch (err) { /* may not exist */ }
-    try { await sdk.api.forms.deleteOne(form.id) } catch (err) { /* may not exist */ }
   }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const formsort_header_auth_tests = async () => {
+  assert_checks('FormSort header auth', await formsort_header_auth_checks())
 }
 
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'FormSort header auth', run: formsort_header_auth_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 formsort_header_auth_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  formsort_header_auth_tests()
     .then(() => {
       console.log("✅ FormSort header auth tests completed successfully")
       process.exit(0)

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

@@ -1,15 +1,17 @@
 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)
+
 /**
  * Google Calendar sync retry — integration coverage.
  *
@@ -43,62 +45,82 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
  *   5. update + delete: same as (1) for events.patch and events.delete
  *   6. cap exceeded:   maxOpenRetries=2, 3 events all fail retryably -> 3rd -> background_errors immediately
  *
- * The runnable assertions below cover what IS observable end-to-end without a
+ * The runnable assertion below covers what IS observable end-to-end without a
  * connected Google account: the refactored call sites must not regress the common
  * "user has no Google integration" path (no sync attempt, no background_errors, no retry).
+ *
+ * Provisions its own throwaway tenant: the check counts "Google Calendar Push Error" rows in
+ * background_errors, which is an org-wide collection, and it reads them for the suite's own user —
+ * on the shared fixture that user is reused by every other suite, so an unrelated calendar event
+ * created concurrently could put a row under this count.
  */
-export const gcal_sync_retry_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Google Calendar Sync Retry")
+export const gcal_sync_retry_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
   if (process.env.GCAL_RETRY_INTEGRATION !== '1') {
     console.log("ℹ️  Skipping mock-Google scenarios (set GCAL_RETRY_INTEGRATION=1 with a server-side "
       + "fault-injection hook to run scenarios 1-6). Running no-integration regression checks only.")
   }
 
-  // No-integration regression check: a calendar event with a user attendee whose
-  // account has no Google integration should sync-skip silently (no background_errors).
-  const enduser = await sdk.api.endusers.createOne({ fname: 'GcalRetry', lname: 'Test' })
-
-  await async_test(
-    'create event for user without Google integration does not produce a background error',
-    async () => {
-      const event = await sdk.api.calendar_events.createOne({
-        title: 'Gcal Retry Regression',
-        startTimeInMS: Date.now() + 1000 * 60 * 60,
-        durationInMinutes: 30,
-        attendees: [{ type: 'user', id: sdk.userInfo.id }, { type: 'enduser', id: enduser.id }],
-      })
-
-      // give side-effect handlers a moment to run
-      await wait(undefined, 750)
-
-      const errors = await sdk.api.background_errors.getSome({}).catch(() => [])
-
-      // clean up
-      await sdk.api.calendar_events.deleteOne(event.id).catch(() => {})
-
-      // No Google integration on the test user => no push attempt => no error row.
-      return errors.filter((e: any) => (
-        e.userId === sdk.userInfo.id && e.title === "Google Calendar Push Error"
-      )).length
-    },
-    { onResult: (count) => count === 0 },
-  )
-
-  // cleanup
-  await sdk.api.endusers.deleteOne(enduser.id).catch(() => {})
-}
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
-if (require.main === module) {
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+  try {
+    tenant = await setup_isolated_tenant({
+      name: `Google Calendar sync retry ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    // No-integration regression check: a calendar event with a user attendee whose
+    // account has no Google integration should sync-skip silently (no background_errors).
+    const enduser = await sdk.api.endusers.createOne({ fname: 'GcalRetry', lname: 'Test' })
+
+    await sdk.api.calendar_events.createOne({
+      title: 'Gcal Retry Regression',
+      startTimeInMS: Date.now() + 1000 * 60 * 60,
+      durationInMinutes: 30,
+      attendees: [{ type: 'user', id: sdk.userInfo.id }, { type: 'enduser', id: enduser.id }],
+    })
+
+    // give side-effect handlers a moment to run
+    await wait(undefined, 750)
+
+    const errors = await sdk.api.background_errors.getSome({}).catch(() => [])
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await gcal_sync_retry_tests({ sdk, sdkNonAdmin })
+    // No Google integration on the test user => no push attempt => no error row.
+    const pushErrors = errors.filter((e: any) => (
+      e.userId === sdk.userInfo.id && e.title === "Google Calendar Push Error"
+    ))
+    record(
+      'create event for user without Google integration does not produce a background error',
+      pushErrors.length === 0,
+      `"Google Calendar Push Error" rows for this user: ${pushErrors.length} (want 0)`
+        + (pushErrors.length ? ` — ${JSON.stringify(pushErrors.map((e: any) => e.message ?? e.title))}` : ''),
+    )
+  } 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) } }
   }
 
-  runTests()
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const gcal_sync_retry_tests = async () => {
+  assert_checks('Google Calendar sync retry', await gcal_sync_retry_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Google Calendar sync retry',
+  run: gcal_sync_retry_checks,
+}
+
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  gcal_sync_retry_tests()
     .then(() => { console.log("✅ gcal sync retry test suite completed successfully"); process.exit(0) })
     .catch((error) => { console.error("❌ gcal sync retry test suite failed:", error); process.exit(1) })
 }