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

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

@@ -1,51 +1,97 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import { log_header, wait, async_test } from "@tellescope/testing"
+import { poll_for_results, wait } from "@tellescope/testing"
 import { Enduser } from "@tellescope/types-client"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || "http://localhost:8080"
 
-export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Form Submitted Trigger Tests (Multi-Form & Per-Form Conditions)")
-
-  // Setup: two forms with one string field each
-  const formA = await sdk.api.forms.createOne({ title: 'Form Submitted Trigger Test A' })
-  const fieldA = await sdk.api.form_fields.createOne({
-    formId: formA.id,
-    type: 'string',
-    title: 'FieldA',
-    previousFields: [{ type: 'root', info: {} }],
-  })
-
-  const formB = await sdk.api.forms.createOne({ title: 'Form Submitted Trigger Test B' })
-  const fieldB = await sdk.api.form_fields.createOne({
-    formId: formB.id,
-    type: 'string',
-    title: 'FieldB',
-    previousFields: [{ type: 'root', info: {} }],
-  })
-
-  // Helper to prepare and submit a form response
-  const submitForm = async (formId: string, enduserId: string, responses: { fieldId: string, fieldTitle: string, answer: { type: 'string', value: string } }[]) => {
-    const { accessCode } = await sdk.api.form_responses.prepare_form_response({ enduserId, formId })
-    await sdk.api.form_responses.submit_form_response({ accessCode, responses })
-  }
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Form Submitted trigger coverage: global-conditions backwards compatibility, `otherFormIds`
+ * multi-form firing, `conditionsByFormId` on the primary and on a secondary form, no cross-form
+ * blocking, and per-form conditions overriding global ones (6b must NOT fire).
+ *
+ * Runs on its own provisioned tenant: the six triggers it installs are org-wide, so on the shared
+ * organization they evaluated every form submission any concurrently running suite made. It never
+ * calls `sdk.reset_db()`, which clears throttle namespaces shared with other suites.
+ *
+ * Each scenario uses its own enduser — triggers are throttled to one fire per trigger per enduser
+ * per minute — and the `wait` after each submission is the trigger-processing barrier. The positive
+ * scenarios then poll for the tag, which returns immediately once it is visible. Scenario 6b, the
+ * negative case, cannot poll for an absence, so it installs a second, unconditional trigger on the
+ * same form and polls for THAT tag instead: the pass that had to reject trigger6 is then known to
+ * have run, and the absence of `override-test` means something.
+ *
+ * Records are not deleted individually: the tenant teardown in the `finally` removes everything it
+ * owns.
+ */
+export const form_submitted_trigger_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: `Form Submitted trigger ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    /** Polls the enduser until the trigger's tag shows up (returning at once if it already has),
+     *  then records whether it did. For the scenarios that must FIRE. */
+    const record_tag_fired = async (label: string, enduserId: string, tag: string) => {
+      const enduser: Enduser = await poll_for_results(
+        () => sdk.api.endusers.getOne(enduserId),
+        e => !!e.tags?.includes(tag),
+      )
+      record(
+        label,
+        !!enduser.tags?.includes(tag),
+        `tags=${JSON.stringify(enduser.tags)} expected to include ${tag}`,
+      )
+    }
 
-  // Pre-create endusers for each scenario to avoid throttle
-  const enduserA1 = await sdk.api.endusers.createOne({ fname: 'fst-a1' })
-  const enduserB1 = await sdk.api.endusers.createOne({ fname: 'fst-b1' })
-  const enduserA2 = await sdk.api.endusers.createOne({ fname: 'fst-a2' })
-  const enduserB2 = await sdk.api.endusers.createOne({ fname: 'fst-b2' })
-  const enduserB3 = await sdk.api.endusers.createOne({ fname: 'fst-b3' })
-  const enduserA3 = await sdk.api.endusers.createOne({ fname: 'fst-a3' })
-  const enduserA4 = await sdk.api.endusers.createOne({ fname: 'fst-a4' })
+    // Setup: two forms with one string field each
+    const formA = await sdk.api.forms.createOne({ title: 'Form Submitted Trigger Test A' })
+    const fieldA = await sdk.api.form_fields.createOne({
+      formId: formA.id,
+      type: 'string',
+      title: 'FieldA',
+      previousFields: [{ type: 'root', info: {} }],
+    })
 
-  const allEndusers = [enduserA1, enduserB1, enduserA2, enduserB2, enduserB3, enduserA3, enduserA4]
-  const allTriggers: { id: string }[] = []
+    const formB = await sdk.api.forms.createOne({ title: 'Form Submitted Trigger Test B' })
+    const fieldB = await sdk.api.form_fields.createOne({
+      formId: formB.id,
+      type: 'string',
+      title: 'FieldB',
+      previousFields: [{ type: 'root', info: {} }],
+    })
+
+    // Helper to prepare and submit a form response
+    const submitForm = async (formId: string, enduserId: string, responses: { fieldId: string, fieldTitle: string, answer: { type: 'string', value: string } }[]) => {
+      const { accessCode } = await sdk.api.form_responses.prepare_form_response({ enduserId, formId })
+      await sdk.api.form_responses.submit_form_response({ accessCode, responses })
+    }
+
+    // Pre-create endusers for each scenario to avoid throttle
+    const enduserA1 = await sdk.api.endusers.createOne({ fname: 'fst-a1' })
+    const enduserB1 = await sdk.api.endusers.createOne({ fname: 'fst-b1' })
+    const enduserA2 = await sdk.api.endusers.createOne({ fname: 'fst-a2' })
+    const enduserB2 = await sdk.api.endusers.createOne({ fname: 'fst-b2' })
+    const enduserB3 = await sdk.api.endusers.createOne({ fname: 'fst-b3' })
+    const enduserA3 = await sdk.api.endusers.createOne({ fname: 'fst-a3' })
+    const enduserA4 = await sdk.api.endusers.createOne({ fname: 'fst-a4' })
 
-  try {
     // ── Scenario 1: Backwards compatibility — global conditions on primary form ──
     const trigger1 = await sdk.api.automation_triggers.createOne({
       event: {
@@ -59,7 +105,6 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
       status: 'Active',
       title: "Scenario 1: Global conditions backwards compat",
     })
-    allTriggers.push(trigger1)
 
     await submitForm(formA.id, enduserA1.id, [{
       fieldId: fieldA.id, fieldTitle: 'FieldA',
@@ -67,10 +112,9 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     }])
     await wait(undefined, 1000)
 
-    await async_test(
+    await record_tag_fired(
       "Scenario 1: Global conditions on primary form still work (backwards compat)",
-      () => sdk.api.endusers.getOne(enduserA1.id),
-      { onResult: (e: Enduser) => !!e.tags?.includes('global-cond-primary') }
+      enduserA1.id, 'global-cond-primary',
     )
 
     await sdk.api.automation_triggers.deleteOne(trigger1.id)
@@ -85,7 +129,6 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
       status: 'Active',
       title: "Scenario 2: Multi-form fires on secondary",
     })
-    allTriggers.push(trigger2)
 
     await submitForm(formB.id, enduserB1.id, [{
       fieldId: fieldB.id, fieldTitle: 'FieldB',
@@ -93,10 +136,9 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     }])
     await wait(undefined, 1000)
 
-    await async_test(
+    await record_tag_fired(
       "Scenario 2: Trigger fires when secondary form (otherFormIds) is submitted",
-      () => sdk.api.endusers.getOne(enduserB1.id),
-      { onResult: (e: Enduser) => !!e.tags?.includes('multi-form-secondary') }
+      enduserB1.id, 'multi-form-secondary',
     )
 
     await sdk.api.automation_triggers.deleteOne(trigger2.id)
@@ -117,7 +159,6 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
       status: 'Active',
       title: "Scenario 3: Per-form conditions on primary",
     })
-    allTriggers.push(trigger3)
 
     await submitForm(formA.id, enduserA2.id, [{
       fieldId: fieldA.id, fieldTitle: 'FieldA',
@@ -125,10 +166,9 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     }])
     await wait(undefined, 1000)
 
-    await async_test(
+    await record_tag_fired(
       "Scenario 3: Per-form conditions match on primary form",
-      () => sdk.api.endusers.getOne(enduserA2.id),
-      { onResult: (e: Enduser) => !!e.tags?.includes('per-form-primary') }
+      enduserA2.id, 'per-form-primary',
     )
 
     await sdk.api.automation_triggers.deleteOne(trigger3.id)
@@ -149,7 +189,6 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
       status: 'Active',
       title: "Scenario 4: Per-form conditions on secondary",
     })
-    allTriggers.push(trigger4)
 
     await submitForm(formB.id, enduserB2.id, [{
       fieldId: fieldB.id, fieldTitle: 'FieldB',
@@ -157,10 +196,9 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     }])
     await wait(undefined, 1000)
 
-    await async_test(
+    await record_tag_fired(
       "Scenario 4: Per-form conditions match on secondary form",
-      () => sdk.api.endusers.getOne(enduserB2.id),
-      { onResult: (e: Enduser) => !!e.tags?.includes('per-form-secondary') }
+      enduserB2.id, 'per-form-secondary',
     )
 
     await sdk.api.automation_triggers.deleteOne(trigger4.id)
@@ -181,7 +219,6 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
       status: 'Active',
       title: "Scenario 5: No cross-form condition blocking",
     })
-    allTriggers.push(trigger5)
 
     await submitForm(formB.id, enduserB3.id, [{
       fieldId: fieldB.id, fieldTitle: 'FieldB',
@@ -189,10 +226,9 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     }])
     await wait(undefined, 1000)
 
-    await async_test(
+    await record_tag_fired(
       "Scenario 5: Conditions on FormA do not block FormB (no cross-form blocking)",
-      () => sdk.api.endusers.getOne(enduserB3.id),
-      { onResult: (e: Enduser) => !!e.tags?.includes('no-cross-block') }
+      enduserB3.id, 'no-cross-block',
     )
 
     await sdk.api.automation_triggers.deleteOne(trigger5.id)
@@ -215,7 +251,6 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
       status: 'Active',
       title: "Scenario 6: conditionsByFormId overrides global",
     })
-    allTriggers.push(trigger6)
 
     // 6a: Submit with per-form matching value — should fire
     await submitForm(formA.id, enduserA3.id, [{
@@ -224,52 +259,83 @@ export const form_submitted_trigger_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     }])
     await wait(undefined, 1000)
 
-    await async_test(
+    await record_tag_fired(
       "Scenario 6a: conditionsByFormId match fires trigger (overrides global)",
-      () => sdk.api.endusers.getOne(enduserA3.id),
-      { onResult: (e: Enduser) => !!e.tags?.includes('override-test') }
+      enduserA3.id, 'override-test',
     )
 
-    // 6b: Submit with global matching value — should NOT fire (per-form takes precedence)
+    // 6b: Submit with global matching value — should NOT fire (per-form takes precedence).
+    //
+    // An unconditional trigger on the same form is the processing barrier for that negative.
+    // handle_form_submitted (api/modules/automation_triggers.ts) loads every Form Submitted trigger
+    // for the form in ONE query and then applies `conditionsByFormId?.[formId] ?? event.conditions`
+    // in a synchronous `.filter()` before it calls handle_actions_for_triggers at all. So this
+    // trigger's tag landing proves that the filter pass — the pass that had to reject trigger6 —
+    // ran. Without it, "no override-test tag" could just mean the read was too early.
+    //
+    // Dispatch ORDER is explicitly NOT what makes this work: findPage defaults to sort='newFirst'
+    // (`_id` descending), so the barrier, created last, is dispatched FIRST and a regressed
+    // trigger6 would write its tag AFTER the barrier's. Hence the settle below before the read.
+    const BARRIER_TAG = `fst-barrier-${RAND()}`
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Form Submitted', info: { formId: formA.id } },
+      action: { type: 'Add Tags', info: { tags: [BARRIER_TAG] } },
+      status: 'Active',
+      title: "Scenario 6b: unconditional processing barrier",
+    })
+
     await submitForm(formA.id, enduserA4.id, [{
       fieldId: fieldA.id, fieldTitle: 'FieldA',
       answer: { type: 'string', value: 'global-value' },
     }])
     await wait(undefined, 1000)
 
-    await async_test(
-      "Scenario 6b: Global conditions ignored when conditionsByFormId exists",
+    const barrierSeen: Enduser = await poll_for_results(
       () => sdk.api.endusers.getOne(enduserA4.id),
-      { onResult: (e: Enduser) => !e.tags?.includes('override-test') }
+      e => !!e.tags?.includes(BARRIER_TAG),
+    )
+    record(
+      "Scenario 6b barrier: the Form Submitted pass ran for the 6b submission",
+      !!barrierSeen.tags?.includes(BARRIER_TAG),
+      `tags=${JSON.stringify(barrierSeen.tags)} expected to include ${BARRIER_TAG}`
+      + ` (without it the negative check below proves nothing)`,
     )
 
-    await sdk.api.automation_triggers.deleteOne(trigger6.id)
+    // Settle: the barrier is dispatched before trigger6 (newest `_id` first), so reading the
+    // instant its tag appears could land between the two writes in the regressed case.
+    await wait(undefined, 1000)
+
+    const enduserA4After = await sdk.api.endusers.getOne(enduserA4.id)
+    record(
+      "Scenario 6b: Global conditions ignored when conditionsByFormId exists",
+      !enduserA4After.tags?.includes('override-test'),
+      `tags=${JSON.stringify(enduserA4After.tags)} expected to exclude override-test`,
+    )
 
+    await sdk.api.automation_triggers.deleteOne(trigger6.id)
   } finally {
-    // Cleanup
-    for (const e of allEndusers) {
-      try { await sdk.api.endusers.deleteOne(e.id) } catch (err) { /* may already be deleted */ }
-    }
-    for (const t of allTriggers) {
-      try { await sdk.api.automation_triggers.deleteOne(t.id) } catch (err) { /* may already be deleted */ }
-    }
-    try { await sdk.api.forms.deleteOne(formA.id) } catch (err) { /* ignore */ }
-    try { await sdk.api.forms.deleteOne(formB.id) } catch (err) { /* ignore */ }
+    // 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 and for sequential use in the suite. */
+export const form_submitted_trigger_tests = async () => {
+  assert_checks('Form Submitted trigger', await form_submitted_trigger_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Form Submitted trigger',
+  run: form_submitted_trigger_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 form_submitted_trigger_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  form_submitted_trigger_tests()
     .then(() => {
       console.log("✅ Form Submitted trigger tests completed successfully")
       process.exit(0)

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

@@ -1,21 +1,22 @@
 require('source-map-support').install();
 
-import { Session, EnduserSession } from "../../sdk"
-import {
-  assert,
-  async_test,
-  handleAnyError,
-  log_header,
-} from "@tellescope/testing"
+import { EnduserSession } from "../../sdk"
 import {
   decodeTranslationMapFromStorage,
   encodeTranslationMapForStorage,
   objects_equivalent,
 } from "@tellescope/utilities"
-import { setup_tests } from "../setup"
+import {
+  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)
+
 // Modular test for AI form translations (display-language maps for v2 forms).
 //
 // Covers:
@@ -29,8 +30,61 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
 //
 // NOTE: this test deliberately does NOT invoke the AI translation endpoint (ai_conversations.send_message) —
 // that path consumes AI credits. Map generation is exercised via manual map fixtures.
-export const form_translations_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Form Translations Tests")
+//
+// Runs on its own provisioned tenant: nothing here needs the hand-seeded shared organization, so the
+// suite joins the auto-discovered parallel pool instead of serialising behind it. The public
+// EnduserSession is pointed at `tenant.businessId` rather than a TEST_BUSINESS_ID env var.
+export const form_translations_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  // The raw value decides the fallback, not JSON.stringify of it — JSON.stringify('') is '""',
+  // which is truthy, so a `|| fallback` on the stringified form could never fire.
+  const describe = (value: any): string => {
+    if (value === undefined || value === null) return String(value)
+    const stringified = JSON.stringify(value)
+    return stringified === undefined ? String(value) : stringified
+  }
+  const errorMessage = (e: any): string => (
+    typeof e?.message === 'string' && e.message !== '' ? e.message : describe(e)
+  )
+
+  /**
+   * The async_test({ onResult }) equivalent, as a soft Check: a call that REJECTS is a failure
+   * (async_test treats it the same way), and a resolved call passes only when onResult agrees.
+   *
+   * The call and the predicate are caught separately, so a predicate that throws fails THIS check
+   * with its own detail instead of being misreported as an API rejection — and never escapes `run`,
+   * which would fail the whole run once the batch settles rather than failing one check.
+   */
+  const expect_result = async <T,>(label: string, fn: () => Promise<T>, onResult: (r: T) => boolean) => {
+    let resolved: { value: T }
+    try {
+      resolved = { value: await fn() }
+    } catch (e: any) {
+      record(label, false, `rejected instead of resolving: ${errorMessage(e)}`)
+      return
+    }
+
+    const { value } = resolved
+    try {
+      record(label, onResult(value), `result=${describe(value)}`)
+    } catch (predicateError: any) {
+      record(label, false, `predicate threw on result=${describe(value)}: ${errorMessage(predicateError)}`)
+    }
+  }
+
+  /**
+   * The async_test(handleAnyError) equivalent: a call that RESOLVES is a failure; any rejection passes.
+   */
+  const expect_rejected = async (label: string, fn: () => Promise<any>) => {
+    try {
+      const unexpected = await fn()
+      record(label, false, `resolved instead of rejecting; result=${describe(unexpected)}`)
+    } catch (e: any) {
+      record(label, true, `rejected with ${errorMessage(e)}`)
+    }
+  }
 
   const ENGLISH_CHOICES = ['Salt & Pepper', '<b>Bold</b> choice', `It's "quoted"`, 'Résumé 中文']
 
@@ -44,12 +98,20 @@ export const form_translations_tests = async ({ sdk } : { sdk: Session, sdkNonAd
     'Hello {{enduser.fname}} <br/> welcome': 'Hola {{enduser.fname}} <br/> bienvenido',
   }
 
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
   const createdConfigurationIds: string[] = []
   let formId: string | undefined
   let fieldId: string | undefined
   let enduserId: string | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Form translations ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     // --- 1. escapeHTML-safe storage round-trip (run first: it guards the whole storage design) ---
     const encoded = encodeTranslationMapForStorage(TRANSLATION_MAP)
     const configuration = await sdk.api.configurations.createOne({
@@ -61,10 +123,10 @@ export const form_translations_tests = async ({ sdk } : { sdk: Session, sdkNonAd
 
     const storedConfiguration = await sdk.api.configurations.getOne(configuration.id)
     const decoded = decodeTranslationMapFromStorage(storedConfiguration.value)
-    assert(
-      objects_equivalent(decoded, TRANSLATION_MAP),
-      `translation map corrupted by storage: ${JSON.stringify(decoded)}`,
+    record(
       'translation map with & < > quotes HTML and non-ASCII survives storage round-trip',
+      objects_equivalent(decoded, TRANSLATION_MAP),
+      `decoded=${JSON.stringify(decoded)}`,
     )
 
     // an unflagged configuration, to verify the publicRead gate on public_form_details
@@ -99,49 +161,48 @@ export const form_translations_tests = async ({ sdk } : { sdk: Session, sdkNonAd
     }, { replaceObjectFields: true })
 
     const updatedForm = await sdk.api.forms.getOne(form.id)
-    assert(
+    record(
+      'form translationConfigurations mapping persists',
       updatedForm.translationConfigurations?.length === 2
       && updatedForm.translationConfigurations.some(t => t.language === 'es' && t.configurationId === configuration.id),
-      `translationConfigurations not persisted: ${JSON.stringify(updatedForm.translationConfigurations)}`,
-      'form translationConfigurations mapping persists',
+      `translationConfigurations=${JSON.stringify(updatedForm.translationConfigurations)}`,
     )
 
     // --- 3. public_form_details language param (unauthenticated) ---
-    const publicSDK = new EnduserSession({ host, businessId: sdk.userInfo.businessId })
+    const publicSDK = new EnduserSession({ host, businessId: tenant.businessId })
 
-    await async_test(
+    await expect_result(
       'public_form_details returns translations for a mapped language with a flagged configuration',
       () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'es' }),
-      { onResult: r => objects_equivalent(r.translations, TRANSLATION_MAP) },
+      r => objects_equivalent(r.translations, TRANSLATION_MAP),
     )
-    await async_test(
+    await expect_result(
       'public_form_details returns no translations without a language param',
       () => publicSDK.api.forms.public_form_details({ formId: form.id }),
-      { onResult: r => !r.translations || Object.keys(r.translations).length === 0 },
+      r => !r.translations || Object.keys(r.translations).length === 0,
     )
-    await async_test(
+    await expect_result(
       'public_form_details returns no translations for an unmapped language',
       () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'de' }),
-      { onResult: r => !r.translations || Object.keys(r.translations).length === 0 },
+      r => !r.translations || Object.keys(r.translations).length === 0,
     )
-    await async_test(
+    await expect_result(
       'public_form_details returns no translations for an UNFLAGGED configuration (publicRead gate)',
       () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'fr' }),
-      { onResult: r => !r.translations || Object.keys(r.translations).length === 0 },
+      r => !r.translations || Object.keys(r.translations).length === 0,
     )
 
     // a form without allowPublicURL still rejects public_form_details entirely
     await sdk.api.forms.updateOne(form.id, { allowPublicURL: false })
-    await async_test(
+    await expect_rejected(
       'public_form_details still rejects forms without allowPublicURL',
       () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'es' }),
-      handleAnyError,
     )
     await sdk.api.forms.updateOne(form.id, { allowPublicURL: true })
 
     // --- 4. viewedInLanguage persists; stored answers remain English ---
     const enduser = await sdk.api.endusers.createOne({
-      email: `form_translations_${Date.now()}@test.tellescope.com`,
+      email: `form_translations_${Date.now()}_${RAND()}@test.tellescope.com`,
     })
     enduserId = enduser.id
 
@@ -160,40 +221,48 @@ export const form_translations_tests = async ({ sdk } : { sdk: Session, sdkNonAd
     })
 
     const storedResponse = await sdk.api.form_responses.getOne(formResponse.id)
-    assert(
-      storedResponse.viewedInLanguage === 'es',
-      `viewedInLanguage not persisted: ${storedResponse.viewedInLanguage}`,
+    record(
       'viewedInLanguage persists on the submitted form response',
+      storedResponse.viewedInLanguage === 'es',
+      `viewedInLanguage=${JSON.stringify(storedResponse.viewedInLanguage)}`,
     )
     const storedAnswer = storedResponse.responses?.find(r => r.fieldId === field.id)
-    assert(
+    record(
+      'stored answer value and fieldTitle remain the English source strings',
       Array.isArray(storedAnswer?.answer?.value)
       && (storedAnswer!.answer.value as string[])[0] === 'Salt & Pepper'
       && storedAnswer!.fieldTitle === 'What is your favorite seasoning?',
-      `stored response not English: ${JSON.stringify(storedAnswer)}`,
-      'stored answer value and fieldTitle remain the English source strings',
+      `storedAnswer=${JSON.stringify(storedAnswer)}`,
     )
   } finally {
-    if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(() => {})
-    if (fieldId) await sdk.api.form_fields.deleteOne(fieldId).catch(() => {})
-    if (formId) await sdk.api.forms.deleteOne(formId).catch(() => {})
-    for (const id of createdConfigurationIds) {
-      await sdk.api.configurations.deleteOne(id).catch(() => {})
+    if (tenant) {
+      const { sdk } = tenant
+      if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(() => {})
+      if (fieldId) await sdk.api.form_fields.deleteOne(fieldId).catch(() => {})
+      if (formId) await sdk.api.forms.deleteOne(formId).catch(() => {})
+      for (const id of createdConfigurationIds) {
+        await sdk.api.configurations.deleteOne(id).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
 }
 
-// Allow running this test file independently
-if (require.main === module) {
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const form_translations_tests = async () => {
+  assert_checks('Form translations', await form_translations_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await form_translations_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Form translations', run: form_translations_checks }
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  form_translations_tests()
     .then(() => {
       console.log("✅ Form translations test suite completed successfully")
       process.exit(0)